Remove calls to deprecated MessageLoop methods on Windows and Linux.

chrome/browser/local_discovery/service_discovery_client_unittest.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 <stdint.h>
 
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 198 matching lines @@
  public:
   ServiceDiscoveryTest()
       : service_discovery_client_(&mdns_client_) {
     mdns_client_.StartListening(&socket_factory_);
   }
 
   ~ServiceDiscoveryTest() override {}
 
  protected:
   void RunFor(base::TimeDelta time_period) {
-    base::CancelableCallback<void()> callback(base::Bind(
-        &ServiceDiscoveryTest::Stop, base::Unretained(this)));
+    base::RunLoop run_loop;
+    base::CancelableCallback<void()> callback(run_loop.QuitWhenIdleClosure());
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, callback.callback(), time_period);
-
-    base::MessageLoop::current()->Run();
+    run_loop.Run();
     callback.Cancel();
   }
 
   void Stop() { base::MessageLoop::current()->QuitWhenIdle(); }
 
   net::MockMDnsSocketFactory socket_factory_;
   net::MDnsClientImpl mdns_client_;
   ServiceDiscoveryClientImpl service_discovery_client_;
   base::MessageLoop loop_;
 };
@@ skipping 46 matching lines @@
   std::unique_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher("_privet._tcp.local",
                                                      delegate.GetCallback()));
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 
 TEST_F(ServiceDiscoveryTest, ReadCachedServicesMultiple) {
   socket_factory_.SimulateReceive(kSamplePacketPTR2, sizeof(kSamplePacketPTR2));
 
   StrictMock<MockServiceWatcherClient> delegate;
   std::unique_ptr<ServiceWatcher> watcher =
       service_discovery_client_.CreateServiceWatcher("_privet._tcp.local",
                                                      delegate.GetCallback());
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "gdbye._privet._tcp.local"))
       .Times(Exactly(1));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 
 TEST_F(ServiceDiscoveryTest, OnServiceChanged) {
   StrictMock<MockServiceWatcherClient> delegate;
   std::unique_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher("_privet._tcp.local",
                                                      delegate.GetCallback()));
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   socket_factory_.SimulateReceive(kSamplePacketPTR, sizeof(kSamplePacketPTR));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_CHANGED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
   socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ServiceDiscoveryTest, SinglePacket) {
   StrictMock<MockServiceWatcherClient> delegate;
   std::unique_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher("_privet._tcp.local",
                                                      delegate.GetCallback()));
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   socket_factory_.SimulateReceive(kSamplePacketPTR, sizeof(kSamplePacketPTR));
 
   // Reset the "already updated" flag.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_CHANGED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
   socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ServiceDiscoveryTest, ActivelyRefreshServices) {
   StrictMock<MockServiceWatcherClient> delegate;
   std::unique_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher("_privet._tcp.local",
                                                      delegate.GetCallback()));
 
   watcher->Start();
   watcher->SetActivelyRefreshServices(true);
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   std::string query_packet = std::string((const char*)(kSamplePacketQuerySRV),
                                          sizeof(kSamplePacketQuerySRV));
 
   EXPECT_CALL(socket_factory_, OnSendTo(query_packet))
       .Times(2);
 
   socket_factory_.SimulateReceive(kSamplePacketPTR, sizeof(kSamplePacketPTR));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
   EXPECT_CALL(socket_factory_, OnSendTo(query_packet))
       .Times(4);  // IPv4 and IPv6 at 85% and 95%
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_REMOVED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   RunFor(base::TimeDelta::FromSeconds(2));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 
 class ServiceResolverTest : public ServiceDiscoveryTest {
  public:
   ServiceResolverTest() {
     metadata_expected_.push_back("hello");
     address_expected_ = net::HostPortPair("myhello.local", 8888);
     EXPECT_TRUE(ip_address_expected_.AssignFromIPLiteral("1.2.3.4"));
   }
@@ skipping 30 matching lines @@
   net::IPAddress ip_address_expected_;
 };
 
 TEST_F(ServiceResolverTest, TxtAndSrvButNoA) {
   EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(4);
 
   resolver_->StartResolving();
 
   socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(
       *this, OnFinishedResolvingInternal(ServiceResolver::STATUS_SUCCESS,
                                          address_expected_.ToString(),
                                          metadata_expected_, net::IPAddress()));
 
   socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 }
 
 TEST_F(ServiceResolverTest, TxtSrvAndA) {
@@ skipping 39 matching lines @@
                          ServiceResolver::STATUS_REQUEST_TIMEOUT, _, _, _));
 
   // TODO(noamsml): When NSEC record support is added, change this to use an
   // NSEC record.
   RunFor(base::TimeDelta::FromSeconds(4));
 }
 
 }  // namespace
 
 }  // namespace local_discovery