components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/devtools_http_handler/devtools_http_handler.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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "components/devtools_discovery/devtools_discovery_manager.h"
 #include "components/devtools_http_handler/devtools_http_handler.h"
 #include "components/devtools_http_handler/devtools_http_handler_delegate.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 213 matching lines @@
     DevToolsHttpHandler::ServerSocketFactory* server_socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     bool bundles_resources) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   scoped_ptr<base::Thread> thread(new base::Thread(kDevToolsHandlerThreadName));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   if (thread->StartWithOptions(options)) {
     base::MessageLoop* message_loop = thread->message_loop();
-    message_loop->PostTask(FROM_HERE,
-        base::Bind(&StartServerOnHandlerThread,
-                   handler,
-                   base::Unretained(thread.release()),
-                   server_socket_factory,
-                   output_directory,
-                   frontend_dir,
-                   bundles_resources));
+    message_loop->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&StartServerOnHandlerThread, handler,
+                   base::Unretained(thread.release()), server_socket_factory,
+                   output_directory, frontend_dir, bundles_resources));
   }
 }
 
 // DevToolsAgentHostClientImpl -----------------------------------------------
 // An internal implementation of DevToolsAgentHostClient that delegates
 // messages sent to a DebuggerShell instance.
 class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
  public:
   DevToolsAgentHostClientImpl(base::MessageLoop* message_loop,
                               ServerWrapper* server_wrapper,
@@ skipping 19 matching lines @@
     DCHECK(agent_host == agent_host_.get());
 
     std::string message = base::StringPrintf(
         "{ \"method\": \"Inspector.detached\", "
         "\"params\": { \"reason\": \"%s\"} }",
         replaced_with_another_client ?
             "replaced_with_devtools" : "target_closed");
     DispatchProtocolMessage(agent_host, message);
 
     agent_host_ = nullptr;
-    message_loop_->PostTask(
+    message_loop_->task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&ServerWrapper::Close,
-                   base::Unretained(server_wrapper_),
+        base::Bind(&ServerWrapper::Close, base::Unretained(server_wrapper_),
                    connection_id_));
   }
 
   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                const std::string& message) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(agent_host == agent_host_.get());
-    message_loop_->PostTask(
+    message_loop_->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ServerWrapper::SendOverWebSocket,
-                   base::Unretained(server_wrapper_),
-                   connection_id_,
-                   message));
+                   base::Unretained(server_wrapper_), connection_id_, message));
   }
 
   void OnMessage(const std::string& message) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (agent_host_.get())
       agent_host_->DispatchProtocolMessage(message);
   }
 
  private:
   base::MessageLoop* const message_loop_;
@@ skipping 364 matching lines @@
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   if (!thread_)
     return;
 
   std::string browser_prefix = "/devtools/browser";
   size_t browser_pos = request.path.find(browser_prefix);
   if (browser_pos == 0) {
     scoped_refptr<DevToolsAgentHost> browser_agent =
         DevToolsAgentHost::CreateForBrowser(
-            thread_->message_loop_proxy(),
+            thread_->task_runner(),
             base::Bind(&ServerSocketFactory::CreateForTethering,
                        base::Unretained(socket_factory_)));
     connection_to_client_[connection_id] = new DevToolsAgentHostClientImpl(
         thread_->message_loop(), server_wrapper_, connection_id, browser_agent);
     AcceptWebSocket(connection_id, request);
     return;
   }
 
   size_t pos = request.path.find(kPageUrlPrefix);
   if (pos != 0) {
@@ skipping 114 matching lines @@
   if (value) {
     base::JSONWriter::WriteWithOptions(
         *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json_value);
   }
   std::string json_message;
   base::JSONWriter::Write(base::StringValue(message), &json_message);
 
   net::HttpServerResponseInfo response(status_code);
   response.SetBody(json_value + message, "application/json; charset=UTF-8");
 
-  thread_->message_loop()->PostTask(
+  thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ServerWrapper::SendResponse,
-                 base::Unretained(server_wrapper_),
-                 connection_id,
-                 response));
+                 base::Unretained(server_wrapper_), connection_id, response));
 }
 
 void DevToolsHttpHandler::Send200(int connection_id,
                                   const std::string& data,
                                   const std::string& mime_type) {
   if (!thread_)
     return;
-  thread_->message_loop()->PostTask(
+  thread_->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&ServerWrapper::Send200,
-                 base::Unretained(server_wrapper_),
-                 connection_id,
-                 data,
-                 mime_type));
+      base::Bind(&ServerWrapper::Send200, base::Unretained(server_wrapper_),
+                 connection_id, data, mime_type));
 }
 
 void DevToolsHttpHandler::Send404(int connection_id) {
   if (!thread_)
     return;
-  thread_->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&ServerWrapper::Send404,
-                 base::Unretained(server_wrapper_),
-                 connection_id));
+  thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ServerWrapper::Send404,
+                            base::Unretained(server_wrapper_), connection_id));
 }
 
 void DevToolsHttpHandler::Send500(int connection_id,
                                   const std::string& message) {
   if (!thread_)
     return;
-  thread_->message_loop()->PostTask(
+  thread_->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&ServerWrapper::Send500,
-                 base::Unretained(server_wrapper_),
-                 connection_id,
-                 message));
+      base::Bind(&ServerWrapper::Send500, base::Unretained(server_wrapper_),
+                 connection_id, message));
 }
 
 void DevToolsHttpHandler::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   if (!thread_)
     return;
-  thread_->message_loop()->PostTask(
+  thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ServerWrapper::AcceptWebSocket,
-                 base::Unretained(server_wrapper_),
-                 connection_id,
-                 request));
+                 base::Unretained(server_wrapper_), connection_id, request));
 }
 
 base::DictionaryValue* DevToolsHttpHandler::SerializeDescriptor(
     const DevToolsTargetDescriptor& descriptor,
     const std::string& host) {
   base::DictionaryValue* dictionary = new base::DictionaryValue;
 
   std::string id = descriptor.GetId();
   dictionary->SetString(kTargetIdField, id);
   std::string parent_id = descriptor.GetParentId();
@@ skipping 26 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace devtools_http_handler