chrome: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/common/local_discovery/service_discovery_client_impl.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 <utility>
 
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/common/local_discovery/service_discovery_client_impl.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/record_rdata.h"
 
 namespace local_discovery {
 
 namespace {
 // TODO(noamsml): Make this configurable through the LocalDomainResolver
 // interface.
 const int kLocalDomainSecondAddressTimeoutMs = 100;
@@ skipping 242 matching lines @@
     found->second->set_has_srv(true);
   }
 }
 
 void ServiceWatcherImpl::DeferUpdate(ServiceWatcher::UpdateType update_type,
                                      const std::string& service_name) {
   ServiceListenersMap::iterator found = services_.find(service_name);
 
   if (found != services_.end() && !found->second->update_pending()) {
     found->second->set_update_pending(true);
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&ServiceWatcherImpl::DeliverDeferredUpdate, AsWeakPtr(),
-                   update_type, service_name));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&ServiceWatcherImpl::DeliverDeferredUpdate,
+                              AsWeakPtr(), update_type, service_name));
   }
 }
 
 void ServiceWatcherImpl::DeliverDeferredUpdate(
     ServiceWatcher::UpdateType update_type, const std::string& service_name) {
   ServiceListenersMap::iterator found = services_.find(service_name);
 
   if (found != services_.end()) {
     found->second->set_update_pending(false);
     if (!callback_.is_null())
@@ skipping 32 matching lines @@
 }
 
 void ServiceWatcherImpl::OnNsecRecord(const std::string& name,
                                       unsigned rrtype) {
   // Do nothing. It is an error for hosts to broadcast an NSEC record for PTR
   // on any name.
 }
 
 void ServiceWatcherImpl::ScheduleQuery(int timeout_seconds) {
   if (timeout_seconds <= kMaxRequeryTimeSeconds) {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ServiceWatcherImpl::SendQuery,
-                   AsWeakPtr(),
-                   timeout_seconds * 2 /*next_timeout_seconds*/,
-                   false /*force_update*/),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&ServiceWatcherImpl::SendQuery, AsWeakPtr(),
+                              timeout_seconds * 2 /*next_timeout_seconds*/,
+                              false /*force_update*/),
         base::TimeDelta::FromSeconds(timeout_seconds));
   }
 }
 
 void ServiceWatcherImpl::SendQuery(int next_timeout_seconds,
                                    bool force_update) {
   CreateTransaction(true /*network*/, false /*cache*/, force_update,
                     &transaction_network_);
   ScheduleQuery(next_timeout_seconds);
 }
@@ skipping 208 matching lines @@
       address_ipv6_ = rdata->address();
     }
   }
 
   if (transactions_finished_ == 1 &&
       address_family_ == net::ADDRESS_FAMILY_UNSPECIFIED) {
     timeout_callback_.Reset(base::Bind(
         &LocalDomainResolverImpl::SendResolvedAddresses,
         base::Unretained(this)));
 
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        timeout_callback_.callback(),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, timeout_callback_.callback(),
         base::TimeDelta::FromMilliseconds(kLocalDomainSecondAddressTimeoutMs));
   } else if (transactions_finished_ == 2
       || address_family_ != net::ADDRESS_FAMILY_UNSPECIFIED) {
     SendResolvedAddresses();
   }
 }
 
 bool LocalDomainResolverImpl::IsSuccess() {
   return !address_ipv4_.empty() || !address_ipv6_.empty();
 }
 
 void LocalDomainResolverImpl::SendResolvedAddresses() {
   transaction_a_.reset();
   transaction_aaaa_.reset();
   timeout_callback_.Cancel();
   callback_.Run(IsSuccess(), address_ipv4_, address_ipv6_);
 }
 
 }  // namespace local_discovery