drivefs_http_client.cc 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212
  1. // Copyright 2022 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/components/drivefs/drivefs_http_client.h"
  5. #include <cstdint>
  6. #include <memory>
  7. #include <type_traits>
  8. #include <utility>
  9. #include "ash/components/drivefs/mojom/drivefs.mojom.h"
  10. #include "base/bind.h"
  11. #include "base/containers/enum_set.h"
  12. #include "mojo/public/cpp/bindings/pending_receiver.h"
  13. #include "mojo/public/cpp/bindings/pending_remote.h"
  14. #include "mojo/public/cpp/bindings/receiver.h"
  15. #include "mojo/public/cpp/bindings/receiver_set.h"
  16. #include "mojo/public/cpp/bindings/remote.h"
  17. #include "services/network/public/cpp/resource_request.h"
  18. #include "services/network/public/mojom/data_pipe_getter.mojom.h"
  19. #include "services/network/public/mojom/url_loader.mojom.h"
  20. #include "services/network/public/mojom/url_loader_factory.mojom.h"
  21. #include "services/network/public/mojom/url_response_head.mojom.h"
  22. namespace drivefs {
  23. namespace {
  24. constexpr net::NetworkTrafficAnnotationTag kTrafficAnnotation =
  25. net::DefineNetworkTrafficAnnotation("drivefs_http_client", R"(
  26. semantics {
  27. sender: "Files App - Google Drive"
  28. description: "Files App integrates with Google Drive to provide a "
  29. "local view of what is available on the Google Drive Web interface. "
  30. "This allows users to navigate Google Drive as if it was a local "
  31. "file system."
  32. trigger: "User navigates through the Google Drive directory in the "
  33. "Files App. User opens a file in the Google Drive directory in the "
  34. "Files App. Additionally, the Files App will sync Google Drive data "
  35. "in the background as changes are made on the web or on other "
  36. "devices."
  37. data: "All metadata related to files stored in Google Drive as well "
  38. "as content of files stored in Google Drive."
  39. destination: GOOGLE_OWNED_SERVICE
  40. }
  41. policy {
  42. cookies_allowed: NO
  43. chrome_policy {
  44. DriveDisabled: {
  45. DriveDisabled: true
  46. }
  47. }
  48. }
  49. comments: "There are two policies that control this integration. "
  50. "DriveDisabled will disable all communications while "
  51. "DriveDisabledOverCellular will disable communication over cellular "
  52. "networks"
  53. )");
  54. class DriveFsURLLoaderClient : public network::mojom::URLLoaderClient,
  55. public network::mojom::DataPipeGetter {
  56. public:
  57. DriveFsURLLoaderClient(
  58. mojo::PendingRemote<mojom::HttpDelegate> http_delegate_remote,
  59. const mojom::HttpRequestPtr& request,
  60. mojo::PendingReceiver<network::mojom::DataPipeGetter> data_pipe_receiver,
  61. mojo::PendingRemote<network::mojom::URLLoader> loader_remote)
  62. : request_body_bytes_(request->request_body_bytes),
  63. loader_remote_(std::move(loader_remote)),
  64. http_delegate_remote_(std::move(http_delegate_remote)) {
  65. Clone(std::move(data_pipe_receiver));
  66. http_delegate_remote_.set_disconnect_handler(
  67. base::BindOnce(&DriveFsURLLoaderClient::OnHttpDelegateDisconnect,
  68. weak_ptr_factory_.GetWeakPtr()));
  69. }
  70. private:
  71. enum class CallbackState : size_t {
  72. kBodyRequested,
  73. kResponseReceived,
  74. kRequestComplete,
  75. // Add new states above.
  76. kMin = kBodyRequested,
  77. kMax = kRequestComplete,
  78. };
  79. bool IsFirstCall(CallbackState state) {
  80. if (callback_state_.Has(state)) {
  81. return false;
  82. }
  83. callback_state_.Put(state);
  84. return true;
  85. }
  86. void OnHttpDelegateDisconnect() {
  87. // Cancel the request: The DriveFS side disconnected.
  88. loader_remote_.reset();
  89. }
  90. // URLLoaderClient Impl
  91. void OnReceiveEarlyHints(network::mojom::EarlyHintsPtr early_hints) override {
  92. }
  93. void OnReceiveResponse(network::mojom::URLResponseHeadPtr response_head,
  94. mojo::ScopedDataPipeConsumerHandle body) override {
  95. DCHECK(IsFirstCall(CallbackState::kResponseReceived));
  96. std::vector<mojom::HttpHeaderPtr> headers;
  97. size_t iter = 0;
  98. std::string name;
  99. std::string value;
  100. while (response_head->headers->EnumerateHeaderLines(&iter, &name, &value)) {
  101. headers.push_back(mojom::HttpHeader::New(name, value));
  102. }
  103. http_delegate_remote_->OnReceiveResponse(mojom::HttpResponse::New(
  104. response_head->headers->response_code(), std::move(headers)));
  105. if (body) {
  106. http_delegate_remote_->OnReceiveBody(std::move(body));
  107. }
  108. }
  109. void OnReceiveRedirect(
  110. const net::RedirectInfo& redirect_info,
  111. network::mojom::URLResponseHeadPtr response_head) override {
  112. // Cancel the request: Redirects are not permitted for security reasons.
  113. loader_remote_.reset();
  114. }
  115. void OnUploadProgress(int64_t current_position,
  116. int64_t total_size,
  117. OnUploadProgressCallback ack_callback) override {
  118. std::move(ack_callback).Run();
  119. }
  120. void OnReceiveCachedMetadata(mojo_base::BigBuffer data) override {}
  121. void OnTransferSizeUpdated(int32_t transfer_size_diff) override {}
  122. void OnComplete(const network::URLLoaderCompletionStatus& status) override {
  123. DCHECK(IsFirstCall(CallbackState::kRequestComplete));
  124. http_delegate_remote_->OnRequestComplete(mojom::HttpCompletionStatus::New(
  125. static_cast<mojom::NetError>(status.error_code),
  126. status.decoded_body_length));
  127. }
  128. // DataPipeGetter Impl
  129. void Read(mojo::ScopedDataPipeProducerHandle pipe,
  130. ReadCallback callback) override {
  131. DCHECK(request_body_bytes_);
  132. DCHECK(IsFirstCall(CallbackState::kBodyRequested));
  133. std::move(callback).Run(net::OK, request_body_bytes_);
  134. http_delegate_remote_->GetRequestBody(std::move(pipe));
  135. }
  136. void Clone(
  137. mojo::PendingReceiver<network::mojom::DataPipeGetter> receiver) override {
  138. data_pipe_receivers_.Add(this, std::move(receiver));
  139. }
  140. const int64_t request_body_bytes_;
  141. base::EnumSet<CallbackState, CallbackState::kMin, CallbackState::kMax>
  142. callback_state_;
  143. mojo::ReceiverSet<network::mojom::DataPipeGetter> data_pipe_receivers_;
  144. mojo::Remote<network::mojom::URLLoader> loader_remote_;
  145. mojo::Remote<mojom::HttpDelegate> http_delegate_remote_;
  146. base::WeakPtrFactory<DriveFsURLLoaderClient> weak_ptr_factory_{this};
  147. };
  148. } // namespace
  149. DriveFsHttpClient::DriveFsHttpClient(
  150. scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory)
  151. : url_loader_factory_(std::move(url_loader_factory)) {}
  152. DriveFsHttpClient::~DriveFsHttpClient() = default;
  153. void DriveFsHttpClient::ExecuteHttpRequest(
  154. mojom::HttpRequestPtr request,
  155. mojo::PendingRemote<mojom::HttpDelegate> delegate) {
  156. // Build a `URLLoaderClient` for the request. This client will bridge
  157. // communication between DriveFS and Chrome OS.
  158. mojo::PendingRemote<network::mojom::URLLoaderClient> url_loader_client;
  159. mojo::PendingRemote<network::mojom::DataPipeGetter> data_pipe_getter;
  160. mojo::PendingRemote<network::mojom::URLLoader> url_loader;
  161. mojo::PendingReceiver<network::mojom::URLLoader> url_loader_reciever =
  162. url_loader.InitWithNewPipeAndPassReceiver();
  163. mojo::ReceiverId client_id =
  164. clients_.Add(std::make_unique<DriveFsURLLoaderClient>(
  165. std::move(delegate), request,
  166. data_pipe_getter.InitWithNewPipeAndPassReceiver(),
  167. std::move(url_loader)),
  168. url_loader_client.InitWithNewPipeAndPassReceiver());
  169. // Translate the `HttpRequest` from DriveFS into a `network::ResourceRequest`.
  170. network::ResourceRequest resource_request;
  171. resource_request.url = GURL(request->url);
  172. resource_request.method = request->method;
  173. for (const auto& header : request->headers) {
  174. resource_request.headers.SetHeader(header->key, header->value);
  175. }
  176. if (request->request_body_bytes > 0) {
  177. resource_request.request_body = new network::ResourceRequestBody();
  178. resource_request.request_body->AppendDataPipe(std::move(data_pipe_getter));
  179. }
  180. // Start execution, the `DriveFsURLLoaderClient` will remove itself from the
  181. // `clients_` map on completion.
  182. url_loader_factory_->CreateLoaderAndStart(
  183. std::move(url_loader_reciever), /*request_id=*/client_id,
  184. /*options=*/network::mojom::kURLLoadOptionBlockAllCookies,
  185. std::move(resource_request), std::move(url_loader_client),
  186. net::MutableNetworkTrafficAnnotationTag(kTrafficAnnotation));
  187. }
  188. } // namespace drivefs