[chrome/browser/local_discovery] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

chrome/browser/local_discovery/service_discovery_client_mac.mm

 // 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 "chrome/browser/local_discovery/service_discovery_client_mac.h"
 
 #import <Foundation/Foundation.h>
 #import <arpa/inet.h>
 #import <net/if_dl.h>
 
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 
 using local_discovery::ServiceWatcherImplMac;
 using local_discovery::ServiceResolverImplMac;
 
 @interface NetServiceBrowserDelegate
     : NSObject<NSNetServiceBrowserDelegate, NSNetServiceDelegate> {
  @private
   ServiceWatcherImplMac::NetServiceBrowserContainer* container_;  // weak.
   base::scoped_nsobject<NSMutableArray> services_;
@@ skipping 127 matching lines @@
         new base::Thread(kServiceDiscoveryThreadName));
     // Only TYPE_UI uses an NSRunLoop.
     base::Thread::Options options(base::MessageLoop::TYPE_UI, 0);
     service_discovery_thread_->StartWithOptions(options);
   }
 }
 
 ServiceWatcherImplMac::NetServiceBrowserContainer::NetServiceBrowserContainer(
     const std::string& service_type,
     const ServiceWatcher::UpdatedCallback& callback,
-    scoped_refptr<base::MessageLoopProxy> service_discovery_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner)
     : service_type_(service_type),
       callback_(callback),
-      callback_runner_(base::MessageLoopProxy::current()),
+      callback_runner_(base::ThreadTaskRunnerHandle::Get()),
       service_discovery_runner_(service_discovery_runner),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+}
 
 ServiceWatcherImplMac::NetServiceBrowserContainer::
     ~NetServiceBrowserContainer() {
   DCHECK(IsOnServiceDiscoveryThread());
 }
 
 void ServiceWatcherImplMac::NetServiceBrowserContainer::Start() {
   service_discovery_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NetServiceBrowserContainer::StartOnDiscoveryThread,
@@ skipping 43 matching lines @@
   callback_runner_->PostTask(FROM_HERE, base::Bind(callback_, update, service));
 }
 
 void ServiceWatcherImplMac::NetServiceBrowserContainer::DeleteSoon() {
   service_discovery_runner_->DeleteSoon(FROM_HERE, this);
 }
 
 ServiceWatcherImplMac::ServiceWatcherImplMac(
     const std::string& service_type,
     const ServiceWatcher::UpdatedCallback& callback,
-    scoped_refptr<base::MessageLoopProxy> service_discovery_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner)
     : service_type_(service_type),
       callback_(callback),
       started_(false),
       weak_factory_(this) {
   container_.reset(new NetServiceBrowserContainer(
       service_type,
       base::Bind(&ServiceWatcherImplMac::OnServicesUpdate,
                  weak_factory_.GetWeakPtr()),
       service_discovery_runner));
 }
@@ skipping 26 matching lines @@
 void ServiceWatcherImplMac::OnServicesUpdate(ServiceWatcher::UpdateType update,
                                              const std::string& service) {
   VLOG(1) << "ServiceWatcherImplMac::OnServicesUpdate: "
           << service + "." + service_type_;
   callback_.Run(update, service + "." + service_type_);
 }
 
 ServiceResolverImplMac::NetServiceContainer::NetServiceContainer(
     const std::string& service_name,
     const ServiceResolver::ResolveCompleteCallback& callback,
-    scoped_refptr<base::MessageLoopProxy> service_discovery_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner)
     : service_name_(service_name),
       callback_(callback),
-      callback_runner_(base::MessageLoopProxy::current()),
+      callback_runner_(base::ThreadTaskRunnerHandle::Get()),
       service_discovery_runner_(service_discovery_runner),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+}
 
 ServiceResolverImplMac::NetServiceContainer::~NetServiceContainer() {
   DCHECK(IsOnServiceDiscoveryThread());
 }
 
 void ServiceResolverImplMac::NetServiceContainer::StartResolving() {
   service_discovery_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NetServiceContainer::StartResolvingOnDiscoveryThread,
                  weak_factory_.GetWeakPtr()));
@@ skipping 67 matching lines @@
 }
 
 void ServiceResolverImplMac::NetServiceContainer::SetServiceForTesting(
     base::scoped_nsobject<NSNetService> service) {
   service_ = service;
 }
 
 ServiceResolverImplMac::ServiceResolverImplMac(
     const std::string& service_name,
     const ServiceResolver::ResolveCompleteCallback& callback,
-    scoped_refptr<base::MessageLoopProxy> service_discovery_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> service_discovery_runner)
     : service_name_(service_name),
       callback_(callback),
       has_resolved_(false),
       weak_factory_(this) {
   container_.reset(new NetServiceContainer(
       service_name,
       base::Bind(&ServiceResolverImplMac::OnResolveComplete,
                  weak_factory_.GetWeakPtr()),
       service_discovery_runner));
 }
@@ skipping 86 matching lines @@
   container_->OnResolveUpdate(local_discovery::ServiceResolver::STATUS_SUCCESS);
 }
 
 - (void)netService:(NSNetService *)sender
         didNotResolve:(NSDictionary *)errorDict {
   container_->OnResolveUpdate(
       local_discovery::ServiceResolver::STATUS_REQUEST_TIMEOUT);
 }
 
 @end