content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/browser/renderer_host/websocket_host.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 "content/browser/renderer_host/websocket_host.h"
 
 #include "base/basictypes.h"
+#include "base/location.h"
 #include "base/memory/weak_ptr.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/websocket_dispatcher_host.h"
 #include "content/browser/ssl/ssl_error_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/common/websocket_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/ssl/ssl_info.h"
 #include "net/websockets/websocket_channel.h"
@@ skipping 328 matching lines @@
     const url::Origin& origin,
     int render_frame_id) {
   DVLOG(3) << "WebSocketHost::OnAddChannelRequest"
            << " routing_id=" << routing_id_ << " socket_url=\"" << socket_url
            << "\" requested_protocols=\""
            << JoinString(requested_protocols, ", ") << "\" origin=\""
            << origin.string() << "\"";
 
   DCHECK(!channel_);
   if (delay_ > base::TimeDelta()) {
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&WebSocketHost::AddChannel,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   socket_url,
-                   requested_protocols,
-                   origin,
-                   render_frame_id),
+        base::Bind(&WebSocketHost::AddChannel, weak_ptr_factory_.GetWeakPtr(),
+                   socket_url, requested_protocols, origin, render_frame_id),
         delay_);
   } else {
     AddChannel(socket_url, requested_protocols, origin, render_frame_id);
   }
   // |this| may have been deleted here.
 }
 
 void WebSocketHost::AddChannel(
     const GURL& socket_url,
     const std::vector<std::string>& requested_protocols,
@@ skipping 11 matching lines @@
       new WebSocketEventHandler(dispatcher_, routing_id_, render_frame_id));
   channel_.reset(
       new net::WebSocketChannel(event_interface.Pass(), url_request_context_));
 
   if (pending_flow_control_quota_ > 0) {
     // channel_->SendFlowControl(pending_flow_control_quota_) must be called
     // after channel_->SendAddChannelRequest() below.
     // We post OnFlowControl() here using |weak_ptr_factory_| instead of
     // calling SendFlowControl directly, because |this| may have been deleted
     // after channel_->SendAddChannelRequest().
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&WebSocketHost::OnFlowControl,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   pending_flow_control_quota_));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&WebSocketHost::OnFlowControl,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              pending_flow_control_quota_));
     pending_flow_control_quota_ = 0;
   }
 
   channel_->SendAddChannelRequest(socket_url, requested_protocols, origin);
   // |this| may have been deleted here.
 }
 
 void WebSocketHost::OnSendFrame(bool fin,
                                 WebSocketMessageType type,
                                 const std::vector<char>& data) {
@@ skipping 37 matching lines @@
                                    "");
     DCHECK_EQ(WebSocketDispatcherHost::WEBSOCKET_HOST_DELETED, result);
     return;
   }
 
   // TODO(yhirano): Handle |was_clean| appropriately.
   channel_->StartClosingHandshake(code, reason);
 }
 
 }  // namespace content