Use TaskScheduler instead of PostTask in P2PSocketDispatcherHost.

content/browser/renderer_host/p2p/socket_dispatcher_host.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/browser/renderer_host/p2p/socket_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/renderer_host/p2p/socket_host.h"
 #include "content/common/p2p_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_context.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/sys_addrinfo.h"
@@ skipping 89 matching lines @@
 };
 
 P2PSocketDispatcherHost::P2PSocketDispatcherHost(
     content::ResourceContext* resource_context,
     net::URLRequestContextGetter* url_context)
     : BrowserMessageFilter(P2PMsgStart),
       resource_context_(resource_context),
       url_context_(url_context),
       monitoring_networks_(false),
       dump_incoming_rtp_packet_(false),
-      dump_outgoing_rtp_packet_(false) {
-}
+      dump_outgoing_rtp_packet_(false),
+      network_list_task_runner_(base::CreateSequencedTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})) {}
 
 void P2PSocketDispatcherHost::OnChannelClosing() {
   // Since the IPC sender is gone, close pending connections.
   sockets_.clear();
 
   dns_requests_.clear();
 
   if (monitoring_networks_) {
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
     monitoring_networks_ = false;
@@ skipping 18 matching lines @@
     IPC_MESSAGE_HANDLER(P2PHostMsg_Send, OnSend)
     IPC_MESSAGE_HANDLER(P2PHostMsg_SetOption, OnSetOption)
     IPC_MESSAGE_HANDLER(P2PHostMsg_DestroySocket, OnDestroySocket)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void P2PSocketDispatcherHost::OnIPAddressChanged() {
   // Notify the renderer about changes to list of network interfaces.
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE, base::Bind(
-          &P2PSocketDispatcherHost::DoGetNetworkList, this));
+  network_list_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&P2PSocketDispatcherHost::DoGetNetworkList, this));
 }
 
 void P2PSocketDispatcherHost::StartRtpDump(
     bool incoming,
     bool outgoing,
     const RenderProcessHost::WebRtcRtpPacketCallback& packet_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if ((!dump_incoming_rtp_packet_ && incoming) ||
       (!dump_outgoing_rtp_packet_ && outgoing)) {
@@ skipping 33 matching lines @@
   SocketsMap::iterator it = sockets_.find(socket_id);
   return (it == sockets_.end()) ? nullptr : it->second.get();
 }
 
 void P2PSocketDispatcherHost::OnStartNetworkNotifications() {
   if (!monitoring_networks_) {
     net::NetworkChangeNotifier::AddIPAddressObserver(this);
     monitoring_networks_ = true;
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE, base::Bind(
-          &P2PSocketDispatcherHost::DoGetNetworkList, this));
+  network_list_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&P2PSocketDispatcherHost::DoGetNetworkList, this));
 }
 
 void P2PSocketDispatcherHost::OnStopNetworkNotifications() {
   if (monitoring_networks_) {
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
     monitoring_networks_ = false;
   }
 }
 
 void P2PSocketDispatcherHost::OnGetHostAddress(const std::string& host_name,
@@ skipping 129 matching lines @@
     const net::IPAddress& default_ipv4_local_address,
     const net::IPAddress& default_ipv6_local_address) {
   Send(new P2PMsg_NetworkListChanged(list, default_ipv4_local_address,
                                      default_ipv6_local_address));
 }
 
 net::IPAddress P2PSocketDispatcherHost::GetDefaultLocalAddress(int family) {
   DCHECK(family == AF_INET || family == AF_INET6);
 
   // Creation and connection of a UDP socket might be janky.
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(network_list_task_runner_->RunsTasksInCurrentSequence());
 
   std::unique_ptr<net::DatagramClientSocket> socket(
       net::ClientSocketFactory::GetDefaultFactory()->CreateDatagramClientSocket(
           net::DatagramSocket::DEFAULT_BIND, net::RandIntCallback(), nullptr,
           net::NetLogSource()));
 
   net::IPAddress ip_address;
   if (family == AF_INET) {
     ip_address = net::IPAddress(kPublicIPv4Host);
   } else {
@@ skipping 35 matching lines @@
 
     if (!dump_incoming_rtp_packet_ && !dump_outgoing_rtp_packet_)
       packet_callback_.Reset();
 
     for (SocketsMap::iterator it = sockets_.begin(); it != sockets_.end(); ++it)
       it->second->StopRtpDump(incoming, outgoing);
   }
 }
 
 }  // namespace content