components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/browser/devtools/protocol/tethering_handler.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 "content/browser/devtools/protocol/tethering_handler.h"
 
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/server_socket.h"
@@ skipping 311 matching lines @@
 }
 
 
 // TetheringHandler ----------------------------------------------------------
 
 // static
 TetheringHandler::TetheringImpl* TetheringHandler::impl_ = nullptr;
 
 TetheringHandler::TetheringHandler(
     const CreateServerSocketCallback& socket_callback,
-    scoped_refptr<base::MessageLoopProxy> message_loop_proxy)
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : socket_callback_(socket_callback),
-      message_loop_proxy_(message_loop_proxy),
+      task_runner_(task_runner),
       is_active_(false),
       weak_factory_(this) {
 }
 
 TetheringHandler::~TetheringHandler() {
   if (is_active_) {
-    message_loop_proxy_->DeleteSoon(FROM_HERE, impl_);
+    task_runner_->DeleteSoon(FROM_HERE, impl_);
     impl_ = nullptr;
   }
 }
 
 void TetheringHandler::SetClient(scoped_ptr<Client> client) {
   client_.swap(client);
 }
 
 void TetheringHandler::Accepted(uint16 port, const std::string& name) {
   client_->Accepted(AcceptedParams::Create()->set_port(port)
@@ skipping 11 matching lines @@
 }
 
 Response TetheringHandler::Bind(DevToolsCommandId command_id, int port) {
   if (port < kMinTetheringPort || port > kMaxTetheringPort)
     return Response::InvalidParams("port");
 
   if (!Activate())
     return Response::ServerError("Tethering is used by another connection");
 
   DCHECK(impl_);
-  message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&TetheringImpl::Bind, base::Unretained(impl_),
-                 command_id, port));
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&TetheringImpl::Bind, base::Unretained(impl_),
+                            command_id, port));
   return Response::OK();
 }
 
 Response TetheringHandler::Unbind(DevToolsCommandId command_id, int port) {
   if (!Activate())
     return Response::ServerError("Tethering is used by another connection");
 
   DCHECK(impl_);
-  message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&TetheringImpl::Unbind, base::Unretained(impl_),
-                 command_id, port));
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&TetheringImpl::Unbind, base::Unretained(impl_),
+                            command_id, port));
   return Response::OK();
 }
 
 void TetheringHandler::SendBindSuccess(DevToolsCommandId command_id) {
   client_->SendBindResponse(command_id, BindResponse::Create());
 }
 
 void TetheringHandler::SendUnbindSuccess(DevToolsCommandId command_id) {
   client_->SendUnbindResponse(command_id, UnbindResponse::Create());
 }
 
 void TetheringHandler::SendInternalError(DevToolsCommandId command_id,
                                          const std::string& message) {
   client_->SendError(command_id, Response::InternalError(message));
 }
 
 }  // namespace tethering
 }  // namespace devtools
 }  // namespace content