chrome: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/test/chromedriver/commands.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 "chrome/test/chromedriver/commands.h"
 
 #include <algorithm>
 #include <list>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/capabilities.h"
 #include "chrome/test/chromedriver/chrome/browser_info.h"
 #include "chrome/test/chromedriver/chrome/chrome.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/logging.h"
 #include "chrome/test/chromedriver/session.h"
 #include "chrome/test/chromedriver/session_thread_map.h"
 #include "chrome/test/chromedriver/util.h"
 
@@ skipping 28 matching lines @@
   scoped_ptr<Session> session(new Session(new_id));
   scoped_ptr<base::Thread> thread(new base::Thread(new_id));
   if (!thread->Start()) {
     callback.Run(
         Status(kUnknownError, "failed to start a thread for the new session"),
         scoped_ptr<base::Value>(),
         std::string());
     return;
   }
 
-  thread->message_loop()->PostTask(
+  thread->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SetThreadLocalSession, base::Passed(&session)));
   session_thread_map
       ->insert(std::make_pair(new_id, make_linked_ptr(thread.release())));
   init_session_cmd.Run(params, new_id, callback);
 }
 
 namespace {
 
 void OnGetSession(const base::WeakPtr<size_t>& session_remaining_count,
                   const base::Closure& all_get_session_func,
@@ skipping 40 matching lines @@
        iter != session_thread_map->end();
        ++iter) {
     session_capabilities_command.Run(params,
                                      iter->first,
                                      base::Bind(
                                                &OnGetSession,
                                                weak_ptr_factory.GetWeakPtr(),
                                                run_loop.QuitClosure(),
                                                session_list.get()));
   }
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      run_loop.QuitClosure(),
-      base::TimeDelta::FromSeconds(10));
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, run_loop.QuitClosure(), base::TimeDelta::FromSeconds(10));
   base::MessageLoop::current()->SetNestableTasksAllowed(true);
   run_loop.Run();
 
   callback.Run(Status(kOk), session_list.Pass(), session_id);
 }
 
 namespace {
 
 void OnSessionQuit(const base::WeakPtr<size_t>& quit_remaining_count,
                    const base::Closure& all_quit_func,
@@ skipping 26 matching lines @@
   base::RunLoop run_loop;
   for (SessionThreadMap::const_iterator iter = session_thread_map->begin();
        iter != session_thread_map->end();
        ++iter) {
     quit_command.Run(params,
                      iter->first,
                      base::Bind(&OnSessionQuit,
                                 weak_ptr_factory.GetWeakPtr(),
                                 run_loop.QuitClosure()));
   }
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, run_loop.QuitClosure(), base::TimeDelta::FromSeconds(10));
   // Uses a nested run loop to block this thread until all the quit
   // commands have executed, or the timeout expires.
   base::MessageLoop::current()->SetNestableTasksAllowed(true);
   run_loop.Run();
   callback.Run(Status(kOk), scoped_ptr<base::Value>(), session_id);
 }
 
 namespace {
 
@@ skipping 106 matching lines @@
     const SessionCommand& command,
     bool return_ok_without_session,
     const base::DictionaryValue& params,
     const std::string& session_id,
     const CommandCallback& callback) {
   SessionThreadMap::iterator iter = session_thread_map->find(session_id);
   if (iter == session_thread_map->end()) {
     Status status(return_ok_without_session ? kOk : kNoSuchSession);
     callback.Run(status, scoped_ptr<base::Value>(), session_id);
   } else {
-    iter->second->message_loop()
-        ->PostTask(FROM_HERE,
-                   base::Bind(&ExecuteSessionCommandOnSessionThread,
-                              command_name,
-                              command,
-                              return_ok_without_session,
+    iter->second->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&ExecuteSessionCommandOnSessionThread,
+                              command_name, command, return_ok_without_session,
                               base::Passed(make_scoped_ptr(params.DeepCopy())),
-                              base::MessageLoopProxy::current(),
-                              callback,
+                              base::ThreadTaskRunnerHandle::Get(), callback,
                               base::Bind(&TerminateSessionThreadOnCommandThread,
-                                         session_thread_map,
-                                         session_id)));
+                                         session_thread_map, session_id)));
   }
 }
 
 namespace internal {
 
 void CreateSessionOnSessionThreadForTesting(const std::string& id) {
   SetThreadLocalSession(make_scoped_ptr(new Session(id)));
 }
 
 }  // namespace internal