Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

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 75 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 301 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);
 }