Revert "Network Service: Convert port_forwarding_controller.cc to mojo host resolver"

This reverts commit 8e3e6c83.

Reason for revert:
https://bugs.chromium.org/p/chromium/issues/detail?id=896603

Original change's description:
> Network Service: Convert port_forwarding_controller.cc to mojo host resolver
>
> Bug: 874651
> Change-Id: I4762526cc8fc4dbf18512b8ab7fbeeda8434336d
> Reviewed-on: https://chromium-review.googlesource.com/1184306
> Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
> Reviewed-by: Matt Menke <mmenke@chromium.org>
> Commit-Queue: Jun Cai <juncai@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#585658}

TBR=caseq@chromium.org,mmenke@chromium.org,juncai@chromium.org,ericorth@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 874651, 896603
Change-Id: Iaeede103359aeb369589620ec10085dcf20311ee
Reviewed-on: https://chromium-review.googlesource.com/c/1292824
Commit-Queue: Jun Cai <juncai@chromium.org>
Reviewed-by: Jun Cai <juncai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#601390}

chrome/browser/devtools/device/port_forwarding_controller.cc

@@ -20,10 +20,7 @@
 #include "chrome/common/pref_names.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/prefs/pref_service.h"
-#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/storage_partition.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ -145,51 +142,41 @@ net::NetworkTrafficAnnotationTag kPortForwardingControllerTrafficAnnotation =
             "here."
         })");
 
-class SocketTunnel : public network::mojom::ResolveHostClient {
+class SocketTunnel {
  public:
-  static void StartTunnel(Profile* profile,
-                          const std::string& host,
+  static void StartTunnel(const std::string& host,
                           int port,
                           int result,
                           std::unique_ptr<net::StreamSocket> socket) {
     if (result == net::OK)
-      new SocketTunnel(profile, std::move(socket), host, port);
+      new SocketTunnel(std::move(socket), host, port);
   }
 
  private:
-  SocketTunnel(Profile* profile,
-               std::unique_ptr<net::StreamSocket> socket,
+  SocketTunnel(std::unique_ptr<net::StreamSocket> socket,
                const std::string& host,
                int port)
-      : binding_(this),
-        remote_socket_(std::move(socket)),
+      : remote_socket_(std::move(socket)),
         pending_writes_(0),
         pending_destruction_(false) {
-    DCHECK(!binding_);
-    network::mojom::ResolveHostClientPtr client_ptr;
-    binding_.Bind(mojo::MakeRequest(&client_ptr));
-    binding_.set_connection_error_handler(
-        base::BindOnce(&SocketTunnel::OnComplete, base::Unretained(this),
-                       net::ERR_FAILED, base::nullopt));
-    net::HostPortPair host_port_pair(host, port);
-    content::BrowserContext::GetDefaultStoragePartition(profile)
-        ->GetNetworkContext()
-        ->ResolveHost(host_port_pair, nullptr, std::move(client_ptr));
+    host_resolver_ = net::HostResolver::CreateDefaultResolver(nullptr);
+    net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port));
+    int result = host_resolver_->Resolve(
+        request_info, net::DEFAULT_PRIORITY, &address_list_,
+        base::Bind(&SocketTunnel::OnResolved, base::Unretained(this)),
+        &request_, net::NetLogWithSource());
+    if (result != net::ERR_IO_PENDING)
+      OnResolved(result);
   }
 
-  // network::mojom::ResolveHostClient:
-  void OnComplete(
-      int result,
-      const base::Optional<net::AddressList>& resolved_addresses) override {
+  void OnResolved(int result) {
     if (result < 0) {
       SelfDestruct();
       return;
     }
 
-    DCHECK(resolved_addresses && !resolved_addresses->empty());
-
-    host_socket_.reset(new net::TCPClientSocket(
-        resolved_addresses.value(), nullptr, nullptr, net::NetLogSource()));
+    host_socket_.reset(new net::TCPClientSocket(address_list_, nullptr, nullptr,
+                                                net::NetLogSource()));
     result = host_socket_->Connect(base::Bind(&SocketTunnel::OnConnected,
                                               base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
@@ -284,9 +271,11 @@ class SocketTunnel : public network::mojom::ResolveHostClient {
     delete this;
   }
 
-  mojo::Binding<network::mojom::ResolveHostClient> binding_;
   std::unique_ptr<net::StreamSocket> remote_socket_;
   std::unique_ptr<net::StreamSocket> host_socket_;
+  std::unique_ptr<net::HostResolver> host_resolver_;
+  std::unique_ptr<net::HostResolver::Request> request_;
+  net::AddressList address_list_;
   int pending_writes_;
   bool pending_destruction_;
 };
@@ -296,8 +285,7 @@ class SocketTunnel : public network::mojom::ResolveHostClient {
 class PortForwardingController::Connection
     : public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
-  Connection(Profile* profile,
-             Registry* registry,
+  Connection(Registry* registry,
              scoped_refptr<AndroidDeviceManager::Device> device,
              scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
              const ForwardingMap& forwarding_map);
@@ -335,7 +323,6 @@ class PortForwardingController::Connection
   void OnFrameRead(const std::string& message) override;
   void OnSocketClosed() override;
 
-  Profile* profile_;
   PortForwardingController::Registry* registry_;
   scoped_refptr<AndroidDeviceManager::Device> device_;
   scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
@@ -350,13 +337,11 @@ class PortForwardingController::Connection
 };
 
 PortForwardingController::Connection::Connection(
-    Profile* profile,
     Registry* registry,
     scoped_refptr<AndroidDeviceManager::Device> device,
     scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
     const ForwardingMap& forwarding_map)
-    : profile_(profile),
-      registry_(registry),
+    : registry_(registry),
       device_(device),
       browser_(browser),
       command_id_(0),
@@ -518,13 +503,15 @@ void PortForwardingController::Connection::OnFrameRead(
     return;
   std::string destination_host = tokens[0];
 
-  device_->OpenSocket(connection_id.c_str(),
-                      base::Bind(&SocketTunnel::StartTunnel, profile_,
-                                 destination_host, destination_port));
+  device_->OpenSocket(
+      connection_id.c_str(),
+      base::Bind(&SocketTunnel::StartTunnel,
+                 destination_host,
+                 destination_port));
 }
 
 PortForwardingController::PortForwardingController(Profile* profile)
-    : profile_(profile), pref_service_(profile->GetPrefs()) {
+    : pref_service_(profile->GetPrefs()) {
   pref_change_registrar_.Init(pref_service_);
   base::Closure callback = base::Bind(
       &PortForwardingController::OnPrefsChange, base::Unretained(this));
@@ -551,8 +538,8 @@ PortForwardingController::DeviceListChanged(
     auto rit = registry_.find(remote_device->serial());
     if (rit == registry_.end()) {
       if (remote_device->browsers().size() > 0) {
-        new Connection(profile_, &registry_, device,
-                       remote_device->browsers()[0], forwarding_map_);
+        new Connection(&registry_, device, remote_device->browsers()[0],
+                       forwarding_map_);
       }
     } else {
       status.push_back(std::make_pair(rit->second->browser(),

chrome/browser/devtools/device/port_forwarding_controller.h

@@ -40,7 +40,6 @@ class PortForwardingController {
 
   void UpdateConnections();
 
-  Profile* profile_;
   PrefService* pref_service_;
   PrefChangeRegistrar pref_change_registrar_;
   Registry registry_;