Remove Thread wrapper class in forwarder2.

tools/android/forwarder2/host_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/android/forwarder2/host_controller.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 52 matching lines @@
   }
   // When doing dynamically allocation of port, we get the port from the
   // BIND_SUCCESS command we received above.
   device_port_ = device_port_allocated;
   ready_ = true;
   return true;
 }
 
 void HostController::Start() {
   thread_.Start();
+  ReadNextCommandSoon();
+}
+
+void HostController::ReadNextCommandSoon() {
   thread_.message_loop_proxy()->PostTask(
       FROM_HERE,
-      base::Bind(&HostController::ThreadHandler, base::Unretained(this)));
+      base::Bind(&HostController::ReadCommandOnInternalThread,
+                 base::Unretained(this)));
 }
 
-void HostController::ThreadHandler() {
+void HostController::ReadCommandOnInternalThread() {
   CHECK(ready_) << "HostController not ready. Must call Connect() first.";
-  while (true) {
-    if (!ReceivedCommand(command::ACCEPT_SUCCESS, &adb_control_socket_)) {
-      SelfDelete();
+  if (!ReceivedCommand(command::ACCEPT_SUCCESS, &adb_control_socket_)) {
+    SelfDelete();
+    return;
+  }
+  // Try to connect to host server.
+  scoped_ptr<Socket> host_server_data_socket(CreateSocket());
+  if (!host_server_data_socket->ConnectTcp(
+          forward_to_host_, forward_to_host_port_)) {
+    LOG(ERROR) << "Could not Connect HostServerData socket on port: "
+               << forward_to_host_port_;
+    SendCommand(command::HOST_SERVER_ERROR, device_port_, &adb_control_socket_);
+    if (ReceivedCommand(command::ACK, &adb_control_socket_)) {
+      // It can continue if the host forwarder could not connect to the host
+      // server but the device acknowledged that, so that the device could
+      // re-try later.
+      ReadNextCommandSoon();
       return;
     }
-    // Try to connect to host server.
-    scoped_ptr<Socket> host_server_data_socket(CreateSocket());
-    if (!host_server_data_socket->ConnectTcp(
-            forward_to_host_, forward_to_host_port_)) {
-      LOG(ERROR) << "Could not Connect HostServerData socket on port: "
-                 << forward_to_host_port_;
-      SendCommand(command::HOST_SERVER_ERROR,
-                  device_port_,
-                  &adb_control_socket_);
-      if (ReceivedCommand(command::ACK, &adb_control_socket_)) {
-        // It can continue if the host forwarder could not connect to the host
-        // server but the device acknowledged that, so that the device could
-        // re-try later.
-        continue;
-      }
-      SelfDelete();
-      return;
-    }
-    SendCommand(command::HOST_SERVER_SUCCESS,
-                device_port_,
-                &adb_control_socket_);
-    StartForwarder(host_server_data_socket.Pass());
+    SelfDelete();
+    return;
   }
+  SendCommand(command::HOST_SERVER_SUCCESS, device_port_, &adb_control_socket_);
+  StartForwarder(host_server_data_socket.Pass());
+  ReadNextCommandSoon();
 }
 
 void HostController::StartForwarder(
     scoped_ptr<Socket> host_server_data_socket) {
   scoped_ptr<Socket> adb_data_socket(CreateSocket());
   if (!adb_data_socket->ConnectTcp("", adb_port_)) {
     LOG(ERROR) << "Could not connect AdbDataSocket on port: " << adb_port_;
     SelfDelete();
     return;
   }
   // Open the Adb data connection, and send a command with the
   // |device_forward_port| as a way for the device to identify the connection.
   SendCommand(command::DATA_CONNECTION,
               device_port_,
               adb_data_socket.get());
 
   // Check that the device received the new Adb Data Connection. Note that this
   // check is done through the |adb_control_socket_| that is handled in the
   // DeviceListener thread just after the call to WaitForAdbDataSocket().
   if (!ReceivedCommand(command::ADB_DATA_SOCKET_SUCCESS,
                        &adb_control_socket_)) {
     LOG(ERROR) << "Device could not handle the new Adb Data Connection.";
     SelfDelete();
     return;
   }
-  Forwarder* forwarder = new Forwarder(host_server_data_socket.Pass(),
-                                       adb_data_socket.Pass());
-  // Forwarder object will self delete after returning.
-  forwarder->Start();
+  forwarder2::StartForwarder(
+      host_server_data_socket.Pass(), adb_data_socket.Pass());
 }
 
 scoped_ptr<Socket> HostController::CreateSocket() {
   scoped_ptr<Socket> socket(new Socket());
   socket->AddEventFd(global_exit_notifier_fd_);
   socket->AddEventFd(delete_controller_notifier_.receiver_fd());
   return socket.Pass();
 }
 
 void HostController::SelfDelete() {
@@ skipping 12 matching lines @@
     LOG(ERROR) << "Could not send unmap command for port " << device_port_;
     return;
   }
   if (!ReceivedCommand(command::UNMAP_PORT_SUCCESS, &socket)) {
     LOG(ERROR) << "Unamp command failed for port " << device_port_;
     return;
   }
 }
 
 }  // namespace forwarder2