chrome/browser: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/browser/devtools/device/android_device_manager.cc

 // Copyright 2014 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/browser/devtools/device/android_device_manager.h"
 
 #include <string.h>
 
+#include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread";
 
 const int kBufferSize = 16 * 1024;
 
 static const char kModelOffline[] = "Offline";
 
 static const char kHttpGetRequest[] = "GET %s HTTP/1.1\r\n\r\n";
 
 static const char kWebSocketUpgradeRequest[] = "GET %s HTTP/1.1\r\n"
     "Upgrade: WebSocket\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
     "Sec-WebSocket-Version: 13\r\n"
     "%s"
     "\r\n";
 
 static void PostDeviceInfoCallback(
-    scoped_refptr<base::MessageLoopProxy> response_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> response_task_runner,
     const AndroidDeviceManager::DeviceInfoCallback& callback,
     const AndroidDeviceManager::DeviceInfo& device_info) {
-  response_message_loop->PostTask(FROM_HERE, base::Bind(callback, device_info));
+  response_task_runner->PostTask(FROM_HERE, base::Bind(callback, device_info));
 }
 
 static void PostCommandCallback(
-    scoped_refptr<base::MessageLoopProxy> response_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> response_task_runner,
     const AndroidDeviceManager::CommandCallback& callback,
     int result,
     const std::string& response) {
-  response_message_loop->PostTask(FROM_HERE,
-                                  base::Bind(callback, result, response));
+  response_task_runner->PostTask(FROM_HERE,
+                                 base::Bind(callback, result, response));
 }
 
 static void PostHttpUpgradeCallback(
-    scoped_refptr<base::MessageLoopProxy> response_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> response_task_runner,
     const AndroidDeviceManager::HttpUpgradeCallback& callback,
     int result,
     const std::string& extensions,
     const std::string& body_head,
     scoped_ptr<net::StreamSocket> socket) {
-  response_message_loop->PostTask(
-      FROM_HERE,
-      base::Bind(callback, result, extensions, body_head,
-                 base::Passed(&socket)));
+  response_task_runner->PostTask(
+      FROM_HERE, base::Bind(callback, result, extensions, body_head,
+                            base::Passed(&socket)));
 }
 
 class HttpRequest {
  public:
   typedef AndroidDeviceManager::CommandCallback CommandCallback;
   typedef AndroidDeviceManager::HttpUpgradeCallback HttpUpgradeCallback;
 
   static void CommandRequest(const std::string& request,
                              const CommandCallback& callback,
                              int result,
@@ skipping 187 matching lines @@
 
 class DevicesRequest : public base::RefCountedThreadSafe<DevicesRequest> {
  public:
   typedef AndroidDeviceManager::DeviceInfo DeviceInfo;
   typedef AndroidDeviceManager::DeviceProvider DeviceProvider;
   typedef AndroidDeviceManager::DeviceProviders DeviceProviders;
   typedef AndroidDeviceManager::DeviceDescriptors DeviceDescriptors;
   typedef base::Callback<void(scoped_ptr<DeviceDescriptors>)>
       DescriptorsCallback;
 
-  static void Start(scoped_refptr<base::MessageLoopProxy> device_message_loop,
-                    const DeviceProviders& providers,
-                    const DescriptorsCallback& callback) {
+  static void Start(
+      scoped_refptr<base::SingleThreadTaskRunner> device_task_runner,
+      const DeviceProviders& providers,
+      const DescriptorsCallback& callback) {
     // Don't keep counted reference on calling thread;
     DevicesRequest* request = new DevicesRequest(callback);
     // Avoid destruction while sending requests
     request->AddRef();
     for (DeviceProviders::const_iterator it = providers.begin();
          it != providers.end(); ++it) {
-      device_message_loop->PostTask(
-          FROM_HERE,
-          base::Bind(
-              &DeviceProvider::QueryDevices,
-              *it,
-              base::Bind(&DevicesRequest::ProcessSerials, request, *it)));
+      device_task_runner->PostTask(
+          FROM_HERE, base::Bind(&DeviceProvider::QueryDevices, *it,
+                                base::Bind(&DevicesRequest::ProcessSerials,
+                                           request, *it)));
     }
-    device_message_loop->ReleaseSoon(FROM_HERE, request);
+    device_task_runner->ReleaseSoon(FROM_HERE, request);
   }
 
  private:
   explicit DevicesRequest(const DescriptorsCallback& callback)
-      : response_message_loop_(base::MessageLoopProxy::current()),
+      : response_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         callback_(callback),
-        descriptors_(new DeviceDescriptors()) {
-  }
+        descriptors_(new DeviceDescriptors()) {}
 
   friend class base::RefCountedThreadSafe<DevicesRequest>;
   ~DevicesRequest() {
-    response_message_loop_->PostTask(FROM_HERE,
-        base::Bind(callback_, base::Passed(&descriptors_)));
+    response_task_runner_->PostTask(
+        FROM_HERE, base::Bind(callback_, base::Passed(&descriptors_)));
   }
 
   typedef std::vector<std::string> Serials;
 
   void ProcessSerials(scoped_refptr<DeviceProvider> provider,
                       const Serials& serials) {
     for (Serials::const_iterator it = serials.begin(); it != serials.end();
          ++it) {
       descriptors_->resize(descriptors_->size() + 1);
       descriptors_->back().provider = provider;
       descriptors_->back().serial = *it;
     }
   }
 
-  scoped_refptr<base::MessageLoopProxy> response_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> response_task_runner_;
   DescriptorsCallback callback_;
   scoped_ptr<DeviceDescriptors> descriptors_;
 };
 
 void ReleaseDeviceAndProvider(
     AndroidDeviceManager::DeviceProvider* provider,
     const std::string& serial) {
   provider->ReleaseDevice(serial);
   provider->Release();
 }
@@ skipping 52 matching lines @@
 }
 
 AndroidDeviceManager::DeviceProvider::DeviceProvider() {
 }
 
 AndroidDeviceManager::DeviceProvider::~DeviceProvider() {
 }
 
 void AndroidDeviceManager::Device::QueryDeviceInfo(
     const DeviceInfoCallback& callback) {
-  message_loop_proxy_->PostTask(
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DeviceProvider::QueryDeviceInfo,
-                 provider_,
-                 serial_,
+      base::Bind(&DeviceProvider::QueryDeviceInfo, provider_, serial_,
                  base::Bind(&PostDeviceInfoCallback,
-                            base::MessageLoopProxy::current(),
-                            callback)));
+                            base::ThreadTaskRunnerHandle::Get(), callback)));
 }
 
 void AndroidDeviceManager::Device::OpenSocket(const std::string& socket_name,
                                               const SocketCallback& callback) {
-  message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&DeviceProvider::OpenSocket,
-                 provider_,
-                 serial_,
-                 socket_name,
-                 callback));
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&DeviceProvider::OpenSocket, provider_, serial_,
+                            socket_name, callback));
 }
 
 void AndroidDeviceManager::Device::SendJsonRequest(
     const std::string& socket_name,
     const std::string& request,
     const CommandCallback& callback) {
-  message_loop_proxy_->PostTask(
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DeviceProvider::SendJsonRequest,
-                 provider_,
-                 serial_,
-                 socket_name,
-                 request,
+      base::Bind(&DeviceProvider::SendJsonRequest, provider_, serial_,
+                 socket_name, request,
                  base::Bind(&PostCommandCallback,
-                            base::MessageLoopProxy::current(),
-                            callback)));
+                            base::ThreadTaskRunnerHandle::Get(), callback)));
 }
 
 void AndroidDeviceManager::Device::HttpUpgrade(
     const std::string& socket_name,
     const std::string& url,
     const std::string& extensions,
     const HttpUpgradeCallback& callback) {
-  message_loop_proxy_->PostTask(
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DeviceProvider::HttpUpgrade,
-                 provider_,
-                 serial_,
-                 socket_name,
-                 url,
-                 extensions,
+      base::Bind(&DeviceProvider::HttpUpgrade, provider_, serial_, socket_name,
+                 url, extensions,
                  base::Bind(&PostHttpUpgradeCallback,
-                            base::MessageLoopProxy::current(),
-                            callback)));
+                            base::ThreadTaskRunnerHandle::Get(), callback)));
 }
 
 AndroidDeviceManager::Device::Device(
-    scoped_refptr<base::MessageLoopProxy> device_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> device_task_runner,
     scoped_refptr<DeviceProvider> provider,
     const std::string& serial)
-    : message_loop_proxy_(device_message_loop),
+    : task_runner_(device_task_runner),
       provider_(provider),
       serial_(serial),
       weak_factory_(this) {
 }
 
 AndroidDeviceManager::Device::~Device() {
   std::set<AndroidWebSocket*> sockets_copy(sockets_);
   for (AndroidWebSocket* socket : sockets_copy)
     socket->OnSocketClosed();
 
   provider_->AddRef();
   DeviceProvider* raw_ptr = provider_.get();
   provider_ = NULL;
-  message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&ReleaseDeviceAndProvider,
-                 base::Unretained(raw_ptr),
-                 serial_));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&ReleaseDeviceAndProvider,
+                                    base::Unretained(raw_ptr), serial_));
 }
 
 AndroidDeviceManager::HandlerThread*
 AndroidDeviceManager::HandlerThread::instance_ = NULL;
 
 // static
 scoped_refptr<AndroidDeviceManager::HandlerThread>
 AndroidDeviceManager::HandlerThread::GetInstance() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!instance_)
     new HandlerThread();
   return instance_;
 }
 
 AndroidDeviceManager::HandlerThread::HandlerThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   instance_ = this;
   thread_ = new base::Thread(kDevToolsAdbBridgeThreadName);
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   if (!thread_->StartWithOptions(options)) {
     delete thread_;
     thread_ = NULL;
   }
 }
 
-scoped_refptr<base::MessageLoopProxy>
+scoped_refptr<base::SingleThreadTaskRunner>
 AndroidDeviceManager::HandlerThread::message_loop() {
-  return thread_ ? thread_->message_loop_proxy() : NULL;
+  return thread_ ? thread_->task_runner() : NULL;
 }
 
 // static
 void AndroidDeviceManager::HandlerThread::StopThread(
     base::Thread* thread) {
   thread->Stop();
 }
 
 AndroidDeviceManager::HandlerThread::~HandlerThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 17 matching lines @@
       it != providers_.end(); ++it) {
     (*it)->AddRef();
     DeviceProvider* raw_ptr = it->get();
     *it = NULL;
     handler_thread_->message_loop()->ReleaseSoon(FROM_HERE, raw_ptr);
   }
   providers_ = providers;
 }
 
 void AndroidDeviceManager::QueryDevices(const DevicesCallback& callback) {
-  DevicesRequest::Start(handler_thread_->message_loop(),
-                        providers_,
+  DevicesRequest::Start(handler_thread_->message_loop(), providers_,
                         base::Bind(&AndroidDeviceManager::UpdateDevices,
-                                   weak_factory_.GetWeakPtr(),
-                                   callback));
+                                   weak_factory_.GetWeakPtr(), callback));
 }
 
 AndroidDeviceManager::AndroidDeviceManager()
     : handler_thread_(HandlerThread::GetInstance()),
       weak_factory_(this) {
 }
 
 AndroidDeviceManager::~AndroidDeviceManager() {
   SetDeviceProviders(DeviceProviders());
 }
 
 void AndroidDeviceManager::UpdateDevices(
     const DevicesCallback& callback,
     scoped_ptr<DeviceDescriptors> descriptors) {
   Devices response;
   DeviceWeakMap new_devices;
   for (DeviceDescriptors::const_iterator it = descriptors->begin();
        it != descriptors->end();
        ++it) {
     DeviceWeakMap::iterator found = devices_.find(it->serial);
     scoped_refptr<Device> device;
     if (found == devices_.end() || !found->second ||
         found->second->provider_.get() != it->provider.get()) {
-      device = new Device(handler_thread_->message_loop(),
-          it->provider, it->serial);
+      device =
+          new Device(handler_thread_->message_loop(), it->provider, it->serial);
     } else {
       device = found->second.get();
     }
     response.push_back(device);
     new_devices[it->serial] = device->weak_factory_.GetWeakPtr();
   }
   devices_.swap(new_devices);
   callback.Run(response);
 }