content/child: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/renderer/p2p/socket_dispatcher.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 "content/renderer/p2p/socket_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "content/child/child_process.h"
 #include "content/common/p2p_messages.h"
 #include "content/renderer/p2p/host_address_request.h"
 #include "content/renderer/p2p/network_list_observer.h"
 #include "content/renderer/p2p/socket_client_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "ipc/ipc_sender.h"
 
 namespace content {
 
 P2PSocketDispatcher::P2PSocketDispatcher(
-    base::MessageLoopProxy* ipc_message_loop)
-    : message_loop_(ipc_message_loop),
+    base::SingleThreadTaskRunner* ipc_task_runner)
+    : ipc_task_runner_(ipc_task_runner),
       network_notifications_started_(false),
       network_list_observers_(
           new ObserverListThreadSafe<NetworkListObserver>()),
       sender_(NULL) {
 }
 
 P2PSocketDispatcher::~P2PSocketDispatcher() {
   network_list_observers_->AssertEmpty();
   for (IDMap<P2PSocketClientImpl>::iterator i(&clients_); !i.IsAtEnd();
        i.Advance()) {
     i.GetCurrentValue()->Detach();
   }
 }
 
 void P2PSocketDispatcher::AddNetworkListObserver(
     NetworkListObserver* network_list_observer) {
   network_list_observers_->AddObserver(network_list_observer);
   network_notifications_started_ = true;
   SendP2PMessage(new P2PHostMsg_StartNetworkNotifications());
 }
 
 void P2PSocketDispatcher::RemoveNetworkListObserver(
     NetworkListObserver* network_list_observer) {
   network_list_observers_->RemoveObserver(network_list_observer);
 }
 
 void P2PSocketDispatcher::Send(IPC::Message* message) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   if (!sender_) {
     DLOG(WARNING) << "P2PSocketDispatcher::Send() - Sender closed.";
     delete message;
     return;
   }
 
   sender_->Send(message);
 }
 
 bool P2PSocketDispatcher::OnMessageReceived(const IPC::Message& message) {
@@ skipping 17 matching lines @@
 }
 
 void P2PSocketDispatcher::OnFilterRemoved() {
   sender_ = NULL;
 }
 
 void P2PSocketDispatcher::OnChannelClosing() {
   sender_ = NULL;
 }
 
-base::MessageLoopProxy* P2PSocketDispatcher::message_loop() {
-  return message_loop_.get();
+base::SingleThreadTaskRunner* P2PSocketDispatcher::task_runner() {
+  return ipc_task_runner_.get();
 }
 
 int P2PSocketDispatcher::RegisterClient(P2PSocketClientImpl* client) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   return clients_.Add(client);
 }
 
 void P2PSocketDispatcher::UnregisterClient(int id) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   clients_.Remove(id);
 }
 
 void P2PSocketDispatcher::SendP2PMessage(IPC::Message* msg) {
-  if (!message_loop_->BelongsToCurrentThread()) {
-    message_loop_->PostTask(FROM_HERE,
-                            base::Bind(&P2PSocketDispatcher::Send,
-                                       this, msg));
+  if (!ipc_task_runner_->BelongsToCurrentThread()) {
+    ipc_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&P2PSocketDispatcher::Send, this, msg));
     return;
   }
   Send(msg);
 }
 
 int P2PSocketDispatcher::RegisterHostAddressRequest(
     P2PAsyncAddressResolver* request) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   return host_address_requests_.Add(request);
 }
 
 void P2PSocketDispatcher::UnregisterHostAddressRequest(int id) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   host_address_requests_.Remove(id);
 }
 
 void P2PSocketDispatcher::OnNetworkListChanged(
     const net::NetworkInterfaceList& networks) {
   network_list_observers_->Notify(
       FROM_HERE, &NetworkListObserver::OnNetworkListChanged, networks);
 }
 
 void P2PSocketDispatcher::OnGetHostAddressResult(
@@ skipping 59 matching lines @@
     // hasn't processed the close message by the time it sends the
     // message to the renderer.
     DVLOG(1) << "Received P2P message for socket that doesn't exist.";
     return NULL;
   }
 
   return client;
 }
 
 }  // namespace content