Remove Thread wrapper class in forwarder2.

tools/android/forwarder2/host_forwarder_main.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 <errno.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <cstdio>
 #include <iostream>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/at_exit.h"
+#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/safe_strerror_posix.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
 #include "base/threading/thread.h"
@@ skipping 35 matching lines @@
   static int s_kill_handler_count = 0;
   CHECK(g_notifier);
   // If for some reason the forwarder get stuck in any socket waiting forever,
   // we can send a SIGKILL or SIGINT three times to force it die
   // (non-nicely). This is useful when debugging.
   ++s_kill_handler_count;
   if (!g_notifier->Notify() || s_kill_handler_count > 2)
     exit(1);
 }
 
+// Manages HostController instances. There is one HostController instance for
+// each redirection. Note that redirections can happen with many devices

[bulach, 2013/07/30 11:11:37]

nit: is "redirection" the same as "forwarding" here?

[pliard, 2013/07/30 11:50:20]

Yeah :) Done.

+// (identified with a serial id).
 class HostControllersManager {
  public:
-  HostControllersManager() : has_failed_(false) {}
+  HostControllersManager()
+      : weak_ptr_factory_(this),
+        controllers_(new HostControllerMap()),
+        has_failed_(false) {
+  }
+
+  ~HostControllersManager() {
+    if (!thread_.get())
+      return;
+    // Delete the controllers on the thread they were created on.
+    thread_->message_loop_proxy()->DeleteSoon(
+        FROM_HERE, controllers_.release());
+  }
 
   void HandleRequest(const std::string& device_serial,
                      int device_port,
                      int host_port,
                      scoped_ptr<Socket> client_socket) {
     // Lazy initialize so that the CLI process doesn't get this thread created.
     InitOnce();
     thread_->message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
@@ skipping 14 matching lines @@
 
   void InitOnce() {
     if (thread_.get())
       return;
     at_exit_manager_.reset(new base::AtExitManager());
     thread_.reset(new base::Thread("HostControllersManagerThread"));
     thread_->Start();
   }
 
   // Invoked when a HostController instance reports an error (e.g. due to a
-  // device connectivity issue).
-  void DeleteHostController(HostController* host_controller) {
-    if (!thread_->message_loop_proxy()->RunsTasksOnCurrentThread()) {
-      // This can be invoked from the host controller internal thread.
-      thread_->message_loop_proxy()->PostTask(
-          FROM_HERE,
-          base::Bind(
-              &HostControllersManager::DeleteHostControllerOnInternalThread,
-              base::Unretained(this), host_controller));
+  // device connectivity issue). Note that this could be called after the
+  // controller manager was destroyed which is why a weak pointer is used.
+  static void DeleteHostController(
+      const base::WeakPtr<HostControllersManager>& manager_ptr,
+      scoped_ptr<HostController> host_controller) {
+    HostController* const controller = host_controller.release();
+    HostControllersManager* const manager = manager_ptr.get();
+    if (!manager) {
+      // Note that |controller| is not leaked in this case since the host
+      // controllers manager owns the controllers. If the manager was deleted
+      // then all the controllers (including |controller|) were also deleted.
       return;
     }
-    DeleteHostControllerOnInternalThread(host_controller);
-  }
-
-  void DeleteHostControllerOnInternalThread(HostController* host_controller) {
-    // Note that this will delete |host_controller| which is owned by the map.
-    controllers_.erase(
-        MakeHostControllerMapKey(host_controller->adb_port(),
-                                 host_controller->device_port()));
+    DCHECK(manager->thread_->message_loop_proxy()->RunsTasksOnCurrentThread());
+    // Note that this will delete |controller| which is owned by the map.
+    manager->controllers_->erase(
+        MakeHostControllerMapKey(controller->adb_port(),
+                                 controller->device_port()));
   }
 
   void HandleRequestOnInternalThread(const std::string& device_serial,
                                      int device_port,
                                      int host_port,
                                      scoped_ptr<Socket> client_socket) {
     const int adb_port = GetAdbPortForDevice(device_serial);
     if (adb_port < 0) {
       SendMessage(
           "ERROR: could not get adb port for device. You might need to add "
           "'adb' to your PATH or provide the device serial id.",
           client_socket.get());
       return;
     }
     if (device_port < 0) {
       // Remove the previously created host controller.
       const std::string controller_key = MakeHostControllerMapKey(
           adb_port, -device_port);
-      const HostControllerMap::size_type removed_elements = controllers_.erase(
+      const HostControllerMap::size_type removed_elements = controllers_->erase(
           controller_key);
       SendMessage(
           !removed_elements ? "ERROR: could not unmap port" : "OK",
           client_socket.get());
       return;
     }
     if (host_port < 0) {
       SendMessage("ERROR: missing host port", client_socket.get());
       return;
     }
     const bool use_dynamic_port_allocation = device_port == 0;
     if (!use_dynamic_port_allocation) {
       const std::string controller_key = MakeHostControllerMapKey(
           adb_port, device_port);
-      if (controllers_.find(controller_key) != controllers_.end()) {
+      if (controllers_->find(controller_key) != controllers_->end()) {
         LOG(INFO) << "Already forwarding device port " << device_port
                   << " to host port " << host_port;
         SendMessage(base::StringPrintf("%d:%d", device_port, host_port),
                     client_socket.get());
         return;
       }
     }
     // Create a new host controller.
     scoped_ptr<HostController> host_controller(
-        new HostController(
-            device_port, "127.0.0.1", host_port, adb_port, GetExitNotifierFD(),
+        HostController::Create(
+            device_port, host_port, adb_port, GetExitNotifierFD(),
             base::Bind(&HostControllersManager::DeleteHostController,
-                       base::Unretained(this))));
-    if (!host_controller->Connect()) {
+                       weak_ptr_factory_.GetWeakPtr())));
+    if (!host_controller.get()) {
       has_failed_ = true;
       SendMessage("ERROR: Connection to device failed.", client_socket.get());
       return;
     }
     // Get the current allocated port.
     device_port = host_controller->device_port();
     LOG(INFO) << "Forwarding device port " << device_port << " to host port "
               << host_port;
     const std::string msg = base::StringPrintf("%d:%d", device_port, host_port);
     if (!SendMessage(msg, client_socket.get()))
       return;
     host_controller->Start();
-    controllers_.insert(
+    controllers_->insert(
         std::make_pair(MakeHostControllerMapKey(adb_port, device_port),
                        linked_ptr<HostController>(host_controller.release())));
   }
 
   int GetAdbPortForDevice(const std::string& device_serial) {
     base::hash_map<std::string, int>::const_iterator it =
         device_serial_to_adb_port_map_.find(device_serial);
     if (it != device_serial_to_adb_port_map_.end())
       return it->second;
     Socket bind_socket;
@@ skipping 15 matching lines @@
   }
 
   bool SendMessage(const std::string& msg, Socket* client_socket) {
     bool result = client_socket->WriteString(msg);
     DCHECK(result);
     if (!result)
       has_failed_ = true;
     return result;
   }
 
+  base::WeakPtrFactory<HostControllersManager> weak_ptr_factory_;
   base::hash_map<std::string, int> device_serial_to_adb_port_map_;
-  HostControllerMap controllers_;
+  scoped_ptr<HostControllerMap> controllers_;
   bool has_failed_;
   scoped_ptr<base::AtExitManager> at_exit_manager_;  // Needed by base::Thread.
   scoped_ptr<base::Thread> thread_;
 };
 
 class ServerDelegate : public Daemon::ServerDelegate {
  public:
   ServerDelegate() : has_failed_(false) {}
 
   bool has_failed() const {
@@ skipping 141 matching lines @@
 
   return client_delegate.has_failed() || daemon_delegate.has_failed();
 }
 
 }  // namespace
 }  // namespace forwarder2
 
 int main(int argc, char** argv) {
   return forwarder2::RunHostForwarder(argc, argv);
 }