Migrate remoting::ServiceClient to SimpleURLLoader

TBR=dullweber@chromium.org (for tools/traffic_annotation/summary/annotations.xml)

BUG=773295

Change-Id: Id47e63bd76376712ab8f0a8a68edd501d8db4227
Reviewed-on: https://chromium-review.googlesource.com/1197045
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Joe Downing <joedow@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588143}

remoting/host/setup/host_starter.cc

@@ -43,12 +43,11 @@ HostStarter::~HostStarter() = default;
 
 std::unique_ptr<HostStarter> HostStarter::Create(
     const std::string& chromoting_hosts_url,
-    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
-    net::URLRequestContextGetter* url_request_context_getter) {
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory) {
   return base::WrapUnique(new HostStarter(
       std::make_unique<gaia::GaiaOAuthClient>(url_loader_factory),
       std::make_unique<remoting::ServiceClient>(chromoting_hosts_url,
-                                                url_request_context_getter),
+                                                url_loader_factory),
       remoting::DaemonController::Create()));
 }
 

remoting/host/setup/host_starter.h

@@ -16,10 +16,6 @@
 #include "remoting/host/setup/daemon_controller.h"
 #include "remoting/host/setup/service_client.h"
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace network {
 class SharedURLLoaderFactory;
 }
@@ -44,8 +40,7 @@ class HostStarter : public gaia::GaiaOAuthClient::Delegate,
   // Creates a HostStarter.
   static std::unique_ptr<HostStarter> Create(
       const std::string& chromoting_hosts_url,
-      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
-      net::URLRequestContextGetter* url_request_context_getter);
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory);
 
   // Registers a new host with the Chromoting service, and starts it.
   // |auth_code| must be a valid OAuth2 authorization code, typically acquired

remoting/host/setup/service_client.cc

@@ -10,24 +10,21 @@
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "net/http/http_status_code.h"
-#include "net/url_request/url_fetcher.h"
-#include "net/url_request/url_fetcher_delegate.h"
-#include "net/url_request/url_request_context_getter.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
+#include "services/network/public/cpp/simple_url_loader.h"
 #include "url/gurl.h"
 
 namespace remoting {
 
 class ServiceClient::Core
-    : public base::RefCountedThreadSafe<ServiceClient::Core>,
-      public net::URLFetcherDelegate {
+    : public base::RefCountedThreadSafe<ServiceClient::Core> {
  public:
   Core(const std::string& chromoting_hosts_url,
-       net::URLRequestContextGetter* request_context_getter)
-           : request_context_getter_(request_context_getter),
-             delegate_(nullptr),
-             pending_request_type_(PENDING_REQUEST_NONE),
-             chromoting_hosts_url_(chromoting_hosts_url) {
-  }
+       scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory)
+      : url_loader_factory_(url_loader_factory),
+        delegate_(nullptr),
+        pending_request_type_(PENDING_REQUEST_NONE),
+        chromoting_hosts_url_(chromoting_hosts_url) {}
 
   void RegisterHost(const std::string& host_id,
                     const std::string& host_name,
@@ -40,12 +37,11 @@ class ServiceClient::Core
                       const std::string& oauth_access_token,
                       ServiceClient::Delegate* delegate);
 
-  // net::URLFetcherDelegate implementation.
-  void OnURLFetchComplete(const net::URLFetcher* source) override;
+  void OnURLLoadComplete(std::unique_ptr<std::string> response_body);
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
-  ~Core() override = default;
+  ~Core() = default;
 
   enum PendingRequestType {
     PENDING_REQUEST_NONE,
@@ -53,16 +49,15 @@ class ServiceClient::Core
     PENDING_REQUEST_UNREGISTER_HOST
   };
 
-  void MakeChromotingRequest(net::URLFetcher::RequestType request_type,
-                       const std::string& post_body,
-                       const std::string& url_suffix,
-                       const std::string& oauth_access_token,
-                       ServiceClient::Delegate* delegate);
-  void HandleResponse(const net::URLFetcher* source);
+  void MakeChromotingRequest(const std::string& request_type,
+                             const std::string& post_body,
+                             const std::string& url_suffix,
+                             const std::string& oauth_access_token,
+                             ServiceClient::Delegate* delegate);
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+  scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
   ServiceClient::Delegate* delegate_;
-  std::unique_ptr<net::URLFetcher> request_;
+  std::unique_ptr<network::SimpleURLLoader> url_loader_;
   PendingRequestType pending_request_type_;
   std::string chromoting_hosts_url_;
 };
@@ -85,10 +80,7 @@ void ServiceClient::Core::RegisterHost(
     url_suffix = "?hostClientId=" + host_client_id;
   std::string post_body_str;
   base::JSONWriter::Write(post_body, &post_body_str);
-  MakeChromotingRequest(net::URLFetcher::POST,
-                        url_suffix,
-                        post_body_str,
-                        oauth_access_token,
+  MakeChromotingRequest("POST", url_suffix, post_body_str, oauth_access_token,
                         delegate);
 }
 
@@ -98,62 +90,89 @@ void ServiceClient::Core::UnregisterHost(
     Delegate* delegate) {
   DCHECK(pending_request_type_ == PENDING_REQUEST_NONE);
   pending_request_type_ = PENDING_REQUEST_UNREGISTER_HOST;
-  MakeChromotingRequest(net::URLFetcher::DELETE_REQUEST,
-                        host_id,
-                        std::string(),
-                        oauth_access_token,
+  MakeChromotingRequest("DELETE", host_id, std::string(), oauth_access_token,
                         delegate);
 }
 
 void ServiceClient::Core::MakeChromotingRequest(
-    net::URLFetcher::RequestType request_type,
+    const std::string& request_type,
     const std::string& url_suffix,
     const std::string& request_body,
     const std::string& oauth_access_token,
     ServiceClient::Delegate* delegate) {
-  delegate_ = delegate;
-  request_ = net::URLFetcher::Create(
-      0, GURL(chromoting_hosts_url_ + url_suffix), request_type, this);
-  request_->SetRequestContext(request_context_getter_.get());
-  request_->SetUploadData("application/json; charset=UTF-8", request_body);
-  request_->AddExtraRequestHeader("Authorization: OAuth " + oauth_access_token);
-  request_->Start();
-}
-
-// URLFetcher::Delegate implementation.
-void ServiceClient::Core::OnURLFetchComplete(
-    const net::URLFetcher* source) {
-  HandleResponse(source);
-  request_.reset();
+  auto resource_request = std::make_unique<network::ResourceRequest>();
+  resource_request->url = GURL(chromoting_hosts_url_ + url_suffix);
+  resource_request->method = request_type;
+  resource_request->headers.SetHeader(
+      "Authorization", std::string("OAuth ") + oauth_access_token);
+
+  net::NetworkTrafficAnnotationTag traffic_annotation =
+      net::DefineNetworkTrafficAnnotation("CRD_service_client",
+                                          R"(
+        semantics {
+          sender: "CRD Service Client"
+          description: "Client implementation for the chromoting service."
+          trigger:
+            "Manually triggered running <out>/remoting_start_host."
+          data: "No user data."
+          destination: OTHER
+          destination_other:
+            "The Chrome Remote Desktop client/host the user is connecting to."
+        }
+        policy {
+          cookies_allowed: NO
+          setting:
+            "This request cannot be stopped in settings, but will not be sent "
+            "if user does not use Chrome Remote Desktop."
+          policy_exception_justification:
+            "Not implemented."
+        })");
+
+  url_loader_ = network::SimpleURLLoader::Create(std::move(resource_request),
+                                                 traffic_annotation);
+  url_loader_->AttachStringForUpload(request_body,
+                                     "application/json; charset=UTF-8");
+  url_loader_->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
+      url_loader_factory_.get(),
+      base::BindOnce(&ServiceClient::Core::OnURLLoadComplete,
+                     base::Unretained(this)));
 }
 
-void ServiceClient::Core::HandleResponse(const net::URLFetcher* source) {
+void ServiceClient::Core::OnURLLoadComplete(
+    std::unique_ptr<std::string> response_body) {
   DCHECK(pending_request_type_ != PENDING_REQUEST_NONE);
   PendingRequestType old_type = pending_request_type_;
   pending_request_type_ = PENDING_REQUEST_NONE;
-  if (source->GetResponseCode() == net::HTTP_BAD_REQUEST) {
+
+  int response_code = -1;
+  if (url_loader_->ResponseInfo() && url_loader_->ResponseInfo()->headers) {
+    response_code = url_loader_->ResponseInfo()->headers->response_code();
+  }
+  url_loader_.reset();
+
+  if (response_code == net::HTTP_BAD_REQUEST) {
     delegate_->OnOAuthError();
     return;
   }
 
-  // Treat codes 2xx as successful; for example, HTTP_NO_CONTENT (204) can be
-  // returned from a DELETE_REQUEST.
-  if (source->GetResponseCode() / 100 == 2) {
+  if (response_body) {
+    // Treat codes 2xx as successful; for example, HTTP_NO_CONTENT (204) can be
+    // returned from a DELETE_REQUEST.
+    DCHECK(response_code == -1 || (response_code / 100 == 2));
     switch (old_type) {
       case PENDING_REQUEST_NONE:
         break;
       case PENDING_REQUEST_REGISTER_HOST:
         {
-          std::string data;
-          source->GetResponseAsString(&data);
-          std::unique_ptr<base::Value> message_value =
-              base::JSONReader::Read(data);
-          base::DictionaryValue *dict;
-          std::string code;
-          if (message_value.get() && message_value->is_dict() &&
-              message_value->GetAsDictionary(&dict) &&
-              dict->GetString("data.authorizationCode", &code)) {
-            delegate_->OnHostRegistered(code);
+        std::string data = *response_body;
+        std::unique_ptr<base::Value> message_value =
+            base::JSONReader::Read(data);
+        base::DictionaryValue* dict;
+        std::string code;
+        if (message_value.get() && message_value->is_dict() &&
+            message_value->GetAsDictionary(&dict) &&
+            dict->GetString("data.authorizationCode", &code)) {
+          delegate_->OnHostRegistered(code);
           } else {
             delegate_->OnHostRegistered(std::string());
           }
@@ -165,12 +184,14 @@ void ServiceClient::Core::HandleResponse(const net::URLFetcher* source) {
     }
     return;
   }
-  delegate_->OnNetworkError(source->GetResponseCode());
+
+  delegate_->OnNetworkError(response_code);
 }
 
-ServiceClient::ServiceClient(const std::string& chromoting_hosts_url,
-                             net::URLRequestContextGetter* context_getter) {
-  core_ = new Core(chromoting_hosts_url, context_getter);
+ServiceClient::ServiceClient(
+    const std::string& chromoting_hosts_url,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory) {
+  core_ = new Core(chromoting_hosts_url, url_loader_factory);
 }
 
 ServiceClient::~ServiceClient() = default;

remoting/host/setup/service_client.h

@@ -10,8 +10,8 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 
-namespace net {
-class URLRequestContextGetter;
+namespace network {
+class SharedURLLoaderFactory;
 }
 
 // A class that gives access to the Chromoting service.
@@ -35,8 +35,9 @@ class ServiceClient {
    protected:
     virtual ~Delegate() {}
   };
-  ServiceClient(const std::string& chromoting_hosts_url,
-                net::URLRequestContextGetter* context_getter);
+  ServiceClient(
+      const std::string& chromoting_hosts_url,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory);
   ~ServiceClient();
 
   // Register a host.

remoting/host/setup/start_host_main.cc

@@ -234,8 +234,7 @@ int StartHostMain(int argc, char** argv) {
   // Start the host.
   std::unique_ptr<HostStarter> host_starter(HostStarter::Create(
       remoting::ServiceUrls::GetInstance()->directory_hosts_url(),
-      url_loader_factory_owner.GetURLLoaderFactory(),
-      url_request_context_getter.get()));
+      url_loader_factory_owner.GetURLLoaderFactory()));
   if (redirect_url.empty()) {
     redirect_url = remoting::GetDefaultOauthRedirectUrl();
   }

tools/traffic_annotation/summary/annotations.xml

@@ -10,6 +10,7 @@ Refer to README.md for content description and update process.
 <annotations>
  <item id="CRD_ice_config_request" hash_code="49825319" type="0" content_hash_code="8740825" os_list="linux,windows" file_path="remoting/protocol/http_ice_config_request.cc"/>
  <item id="CRD_relay_session_request" hash_code="24058523" type="0" content_hash_code="36997811" os_list="linux,windows" file_path="remoting/protocol/port_allocator.cc"/>
+ <item id="CRD_service_client" hash_code="25502614" type="0" content_hash_code="76861209" os_list="linux,mac,windows" file_path="remoting/host/setup/service_client.cc"/>
  <item id="CRD_telemetry_log" hash_code="18670926" type="0" content_hash_code="49025478" os_list="linux,windows" file_path="remoting/base/telemetry_log_writer.cc"/>
  <item id="accounts_image_fetcher" hash_code="98658519" type="0" content_hash_code="45432230" os_list="linux,windows" file_path="components/signin/core/browser/account_fetcher_service.cc"/>
  <item id="adb_client_socket" hash_code="87775794" type="0" content_hash_code="56654828" os_list="linux,windows" file_path="chrome/browser/devtools/device/adb/adb_client_socket.cc"/>