Update monet.

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>
 
@@ skipping 10 matching lines @@
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.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/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"
 #include "tools/android/forwarder2/common.h"
 #include "tools/android/forwarder2/daemon.h"
 #include "tools/android/forwarder2/host_controller.h"
@@ skipping 45 matching lines @@
   HostControllersManager()
       : controllers_(new HostControllerMap()),
         has_failed_(false),
         weak_ptr_factory_(this) {
   }
 
   ~HostControllersManager() {
     if (!thread_.get())
       return;
     // Delete the controllers on the thread they were created on.
-    thread_->message_loop_proxy()->DeleteSoon(
-        FROM_HERE, controllers_.release());
+    thread_->task_runner()->DeleteSoon(FROM_HERE, controllers_.release());
   }
 
   void HandleRequest(const std::string& adb_path,
                      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(
+    thread_->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostControllersManager::HandleRequestOnInternalThread,
                    base::Unretained(this), adb_path, device_serial, device_port,
                    host_port, base::Passed(&client_socket)));
   }
 
   bool has_failed() const { return has_failed_; }
 
  private:
   typedef base::hash_map<
@@ skipping 18 matching lines @@
       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;
     }
-    DCHECK(manager->thread_->message_loop_proxy()->RunsTasksOnCurrentThread());
+    DCHECK(manager->thread_->task_runner()->RunsTasksOnCurrentThread());
     // Note that this will delete |controller| which is owned by the map.
     DeleteRefCountedValueInMap(
         MakeHostControllerMapKey(
             controller->adb_port(), controller->device_port()),
         manager->controllers_.get());
   }
 
   void HandleRequestOnInternalThread(const std::string& adb_path,
                                      const std::string& device_serial,
                                      int device_port,
@@ skipping 167 matching lines @@
   void OnClientConnected(scoped_ptr<Socket> client_socket) override {
     char buf[kBufSize];
     const int bytes_read = client_socket->Read(buf, sizeof(buf));
     if (bytes_read <= 0) {
       if (client_socket->DidReceiveEvent())
         return;
       PError("Read()");
       has_failed_ = true;
       return;
     }
-    const Pickle command_pickle(buf, bytes_read);
-    PickleIterator pickle_it(command_pickle);
+    const base::Pickle command_pickle(buf, bytes_read);
+    base::PickleIterator pickle_it(command_pickle);
     std::string device_serial;
     CHECK(pickle_it.ReadString(&device_serial));
     int device_port;
     if (!pickle_it.ReadInt(&device_port)) {
       client_socket->WriteString("ERROR: missing device port");
       return;
     }
     int host_port;
     if (!pickle_it.ReadInt(&host_port))
       host_port = -1;
     controllers_manager_.HandleRequest(adb_path_, device_serial, device_port,
                                        host_port, client_socket.Pass());
   }
 
  private:
   std::string adb_path_;
   bool has_failed_;
   HostControllersManager controllers_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerDelegate);
 };
 
 class ClientDelegate : public Daemon::ClientDelegate {
  public:
-  ClientDelegate(const Pickle& command_pickle)
-      : command_pickle_(command_pickle),
-        has_failed_(false) {
-  }
+  ClientDelegate(const base::Pickle& command_pickle)
+      : command_pickle_(command_pickle), has_failed_(false) {}
 
   bool has_failed() const { return has_failed_; }
 
   // Daemon::ClientDelegate:
   void OnDaemonReady(Socket* daemon_socket) override {
     // Send the forward command to the daemon.
     CHECK_EQ(static_cast<long>(command_pickle_.size()),
              daemon_socket->WriteNumBytes(command_pickle_.data(),
                                           command_pickle_.size()));
     char buf[kBufSize];
     const int bytes_read = daemon_socket->Read(
         buf, sizeof(buf) - 1 /* leave space for null terminator */);
     CHECK_GT(bytes_read, 0);
     DCHECK(static_cast<size_t>(bytes_read) < sizeof(buf));
     buf[bytes_read] = 0;
     base::StringPiece msg(buf, bytes_read);
     if (msg.starts_with("ERROR")) {
       LOG(ERROR) << msg;
       has_failed_ = true;
       return;
     }
     printf("%s\n", buf);
   }
 
  private:
-  const Pickle command_pickle_;
+  const base::Pickle command_pickle_;
   bool has_failed_;
 };
 
 void ExitWithUsage() {
   std::cerr << "Usage: host_forwarder [options]\n\n"
                "Options:\n"
                "  --serial-id=[0-9A-Z]{16}]\n"
                "  --map DEVICE_PORT HOST_PORT\n"
                "  --unmap DEVICE_PORT\n"
                "  --adb PATH_TO_ADB\n"
@@ skipping 11 matching lines @@
   }
   return value;
 }
 
 int RunHostForwarder(int argc, char** argv) {
   base::CommandLine::Init(argc, argv);
   const base::CommandLine& cmd_line = *base::CommandLine::ForCurrentProcess();
   std::string adb_path = "adb";
   bool kill_server = false;
 
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteString(
       cmd_line.HasSwitch("serial-id") ?
           cmd_line.GetSwitchValueASCII("serial-id") : std::string());
 
   const std::vector<std::string> args = cmd_line.GetArgs();
   if (cmd_line.HasSwitch("kill-server")) {
     kill_server = true;
   } else if (cmd_line.HasSwitch("unmap")) {
     if (args.size() != 1)
       ExitWithUsage();
@@ skipping 28 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);
 }