Remove calls to deprecated MessageLoop methods in chromeos.

chromeos/geolocation/simple_geolocation_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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 168 matching lines @@
   }
 
   const Geoposition& position() const { return position_; }
   bool server_error() const { return server_error_; }
   base::TimeDelta elapsed() const { return elapsed_; }
 
  private:
   Geoposition position_;
   bool server_error_;
   base::TimeDelta elapsed_;
   std::unique_ptr<base::RunLoop> message_loop_runner_;

[oshima, 2016/09/13 01:36:05]

can you clean up this too?

(and one in timezone_unittest.cc)

[fdoray, 2016/09/13 13:12:49]

Still used at lines 173, 177, 178.
Same thing in timezone_unittest.cc.

 };
 
 class WiFiTestMonitor : public SimpleGeolocationRequestTestMonitor {
  public:
   WiFiTestMonitor() {}
 
   void OnRequestCreated(SimpleGeolocationRequest* request) override {}
   void OnStart(SimpleGeolocationRequest* request) override {
     last_request_body_ = request->FormatRequestBodyForTesting();
   }
@@ skipping 134 matching lines @@
 
   void SetUp() override {
     // This initializes DBusThreadManager and markes it "for tests only".
     DBusThreadManager::GetSetterForTesting();
     // Get the test interface for manager / device.
     manager_test_ =
         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
     ASSERT_TRUE(manager_test_);
     geolocation_handler_.reset(new GeolocationHandler());
     geolocation_handler_->Init();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override {
     geolocation_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
   bool GetWifiAccessPoints() {
     return geolocation_handler_->GetWifiAccessPoints(&wifi_access_points_,
                                                      nullptr);
   }
 
   void AddAccessPoint(int idx) {
     base::DictionaryValue properties;
     std::string mac_address =
         base::StringPrintf("%02X:%02X:%02X:%02X:%02X:%02X", idx, 0, 0, 0, 0, 0);
     std::string channel = base::IntToString(idx);
     std::string strength = base::IntToString(idx * 10);
     properties.SetStringWithoutPathExpansion(shill::kGeoMacAddressProperty,
                                              mac_address);
     properties.SetStringWithoutPathExpansion(shill::kGeoChannelProperty,
                                              channel);
     properties.SetStringWithoutPathExpansion(shill::kGeoSignalStrengthProperty,
                                              strength);
     manager_test_->AddGeoNetwork(shill::kTypeWifi, properties);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
  protected:
   base::MessageLoopForUI message_loop_;
   std::unique_ptr<GeolocationHandler> geolocation_handler_;
   ShillManagerClient::TestInterface* manager_test_;
   WifiAccessPointVector wifi_access_points_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SimpleGeolocationWiFiTest);
@@ skipping 20 matching lines @@
     receiver.WaitUntilRequestDone();
     EXPECT_EQ(kIPOnlyRequestBody, requests_monitor.last_request_body());
 
     EXPECT_EQ(kExpectedPosition, receiver.position().ToString());
     EXPECT_FALSE(receiver.server_error());
     EXPECT_EQ(1U, url_factory.attempts());
   }
 
   // Add an acces point.
   AddAccessPoint(1);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // Inititial call should return false and request access points.
   EXPECT_FALSE(GetWifiAccessPoints());
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // Second call should return true since we have an access point.
   EXPECT_TRUE(GetWifiAccessPoints());
   ASSERT_EQ(1u, wifi_access_points_.size());
   EXPECT_EQ(kWiFiAP1MacAddress, wifi_access_points_[0].mac_address);
   EXPECT_EQ(1, wifi_access_points_[0].channel);
 
   {
     GeolocationReceiver receiver;
     provider.RequestGeolocation(base::TimeDelta::FromSeconds(1), GetParam(),
                                 base::Bind(&GeolocationReceiver::OnRequestDone,
@@ skipping 14 matching lines @@
   }
   NetworkHandler::Shutdown();
 }
 
 // This test verifies that WiFi data is sent only if sending was requested.
 INSTANTIATE_TEST_CASE_P(EnableDisableSendingWifiData,
                         SimpleGeolocationWiFiTest,
                         testing::Bool());
 
 }  // namespace chromeos