Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

tools/android/forwarder2/forwarders_manager.cc

 // Copyright 2013 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/forwarders_manager.h"
 
 #include <sys/select.h>
 #include <unistd.h>
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/task_runner.h"
 #include "tools/android/forwarder2/forwarder.h"
 #include "tools/android/forwarder2/socket.h"
 
 namespace forwarder2 {
 
 ForwardersManager::ForwardersManager() : thread_("ForwardersManagerThread") {
   thread_.Start();
   WaitForEventsOnInternalThreadSoon();
 }
 
 
 ForwardersManager::~ForwardersManager() {
   deletion_notifier_.Notify();
 }
 
 void ForwardersManager::CreateAndStartNewForwarder(scoped_ptr<Socket> socket1,
                                                    scoped_ptr<Socket> socket2) {
   // Note that the internal Forwarder vector is populated on the internal thread
   // which is the only thread from which it's accessed.
-  thread_.message_loop_proxy()->PostTask(
+  thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ForwardersManager::CreateNewForwarderOnInternalThread,
                  base::Unretained(this), base::Passed(&socket1),
                  base::Passed(&socket2)));
 
   // Guarantees that the CreateNewForwarderOnInternalThread callback posted to
   // the internal thread gets executed immediately.
   wakeup_notifier_.Notify();
 }
 
 void ForwardersManager::CreateNewForwarderOnInternalThread(
     scoped_ptr<Socket> socket1,
     scoped_ptr<Socket> socket2) {
-  DCHECK(thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
+  DCHECK(thread_.task_runner()->RunsTasksOnCurrentThread());
   forwarders_.push_back(new Forwarder(socket1.Pass(), socket2.Pass()));
 }
 
 void ForwardersManager::WaitForEventsOnInternalThreadSoon() {
-  thread_.message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&ForwardersManager::WaitForEventsOnInternalThread,
-                 base::Unretained(this)));
+  thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ForwardersManager::WaitForEventsOnInternalThread,
+                            base::Unretained(this)));
 }
 
 void ForwardersManager::WaitForEventsOnInternalThread() {
-  DCHECK(thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
+  DCHECK(thread_.task_runner()->RunsTasksOnCurrentThread());
   fd_set read_fds;
   fd_set write_fds;
 
   FD_ZERO(&read_fds);
   FD_ZERO(&write_fds);
 
   // Populate the file descriptor sets.
   int max_fd = -1;
   for (ScopedVector<Forwarder>::iterator it = forwarders_.begin();
        it != forwarders_.end(); ++it) {
@@ skipping 48 matching lines @@
       ++i;
       continue;
     }
 
     std::swap(forwarders_[i], forwarders_.back());
     forwarders_.pop_back();
   }
 }
 
 }  // namespace forwarder2