Remove calls to deprecated MessageLoop methods in chromeos.

chromeos/network/network_configuration_handler_unittest.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 <stddef.h>
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/mock_shill_manager_client.h"
 #include "chromeos/dbus/mock_shill_profile_client.h"
 #include "chromeos/dbus/mock_shill_service_client.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_configuration_observer.h"
@@ skipping 174 matching lines @@
     EXPECT_CALL(*mock_manager_client_, GetProperties(_)).Times(AnyNumber());
     EXPECT_CALL(*mock_manager_client_, AddPropertyChangedObserver(_))
         .Times(AnyNumber());
     EXPECT_CALL(*mock_manager_client_, RemovePropertyChangedObserver(_))
         .Times(AnyNumber());
 
     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
     network_configuration_handler_.reset(new NetworkConfigurationHandler());
     network_configuration_handler_->Init(network_state_handler_.get(),
                                          NULL /* network_device_handler */);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override {
     network_configuration_handler_.reset();
     network_state_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
   // Handles responses for GetProperties method calls.
   void OnGetProperties(
@@ skipping 70 matching lines @@
         base::Bind(&ServiceResultCallback, service_path),
         base::Bind(&ErrorCallback, false, std::string()));
   }
 
  protected:
   MockShillManagerClient* mock_manager_client_;
   MockShillProfileClient* mock_profile_client_;
   MockShillServiceClient* mock_service_client_;
   std::unique_ptr<NetworkStateHandler> network_state_handler_;
   std::unique_ptr<NetworkConfigurationHandler> network_configuration_handler_;
   base::MessageLoopForUI message_loop_;

[armansito, 2016/09/06 22:04:32]

ditto

[fdoray, 2016/09/07 13:03:48]

ditto

   base::DictionaryValue* dictionary_value_result_;
 };
 
 TEST_F(NetworkConfigurationHandlerTest, GetProperties) {
   std::string service_path = "/service/1";
   std::string expected_json = "{\n   \"SSID\": \"MyNetwork\"\n}\n";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   std::unique_ptr<base::StringValue> networkNameValue(
       new base::StringValue(networkName));
 
   base::DictionaryValue value;
   value.Set(key, new base::StringValue(networkName));
   dictionary_value_result_ = &value;
   EXPECT_CALL(*mock_service_client_,
               SetProperty(dbus::ObjectPath(service_path), key,
                           IsEqualTo(networkNameValue.get()), _, _)).Times(1);
   mock_service_client_->SetProperty(
       dbus::ObjectPath(service_path), key, *networkNameValue,
       base::Bind(&base::DoNothing), base::Bind(&DBusErrorCallback));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   ShillServiceClient::DictionaryValueCallback get_properties_callback;
   EXPECT_CALL(*mock_service_client_, GetProperties(_, _))
       .WillOnce(
           Invoke(this, &NetworkConfigurationHandlerTest::OnGetProperties));
   network_configuration_handler_->GetShillProperties(
       service_path,
       base::Bind(&DictionaryValueCallback, service_path, expected_json),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, SetProperties) {
   std::string service_path = "/service/1";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   std::unique_ptr<base::StringValue> networkNameValue(
       new base::StringValue(networkName));
 
   base::DictionaryValue value;
   value.Set(key, new base::StringValue(networkName));
   dictionary_value_result_ = &value;
   EXPECT_CALL(*mock_service_client_, SetProperties(_, _, _, _))
       .WillOnce(
           Invoke(this, &NetworkConfigurationHandlerTest::OnSetProperties));
   network_configuration_handler_->SetShillProperties(
       service_path, value, NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, ClearProperties) {
   std::string service_path = "/service/1";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   std::unique_ptr<base::StringValue> networkNameValue(
       new base::StringValue(networkName));
 
   // First set up a value to clear.
   base::DictionaryValue value;
   value.Set(key, new base::StringValue(networkName));
   dictionary_value_result_ = &value;
   EXPECT_CALL(*mock_service_client_, SetProperties(_, _, _, _))
       .WillOnce(
           Invoke(this, &NetworkConfigurationHandlerTest::OnSetProperties));
   network_configuration_handler_->SetShillProperties(
       service_path, value, NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Now clear it.
   std::vector<std::string> values_to_clear;
   values_to_clear.push_back(key);
   EXPECT_CALL(*mock_service_client_, ClearProperties(_, _, _, _))
       .WillOnce(
           Invoke(this, &NetworkConfigurationHandlerTest::OnClearProperties));
   network_configuration_handler_->ClearShillProperties(
       service_path, values_to_clear, base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, ClearPropertiesError) {
   std::string service_path = "/service/1";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   std::unique_ptr<base::StringValue> networkNameValue(
       new base::StringValue(networkName));
 
   // First set up a value to clear.
   base::DictionaryValue value;
   value.Set(key, new base::StringValue(networkName));
   dictionary_value_result_ = &value;
   EXPECT_CALL(*mock_service_client_, SetProperties(_, _, _, _))
       .WillOnce(
           Invoke(this, &NetworkConfigurationHandlerTest::OnSetProperties));
   network_configuration_handler_->SetShillProperties(
       service_path, value, NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Now clear it.
   std::vector<std::string> values_to_clear;
   values_to_clear.push_back(key);
   EXPECT_CALL(*mock_service_client_, ClearProperties(_, _, _, _))
       .WillOnce(Invoke(
           this, &NetworkConfigurationHandlerTest::OnClearPropertiesError));
   network_configuration_handler_->ClearShillProperties(
       service_path, values_to_clear, base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, true, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, CreateConfiguration) {
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
   std::string type = "wifi";
   std::string profile = "profile path";
   base::DictionaryValue value;
   shill_property_util::SetSSID(networkName, &value);
   value.SetWithoutPathExpansion(shill::kTypeProperty,
                                 new base::StringValue(type));
   value.SetWithoutPathExpansion(shill::kProfileProperty,
                                 new base::StringValue(profile));
 
   EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(dbus::ObjectPath(profile), _, _, _))
       .WillOnce(
           Invoke(this, &NetworkConfigurationHandlerTest::OnConfigureService));
   CreateConfiguration("/service/2", value);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, RemoveConfiguration) {
   std::string service_path = "/service/1";
 
   TestCallback test_callback;
   EXPECT_CALL(*mock_service_client_, GetLoadableProfileEntries(_, _))
       .WillOnce(Invoke(
           this, &NetworkConfigurationHandlerTest::OnGetLoadableProfileEntries));
   EXPECT_CALL(*mock_profile_client_, DeleteEntry(_, _, _, _))
       .WillRepeatedly(
           Invoke(this, &NetworkConfigurationHandlerTest::OnDeleteEntry));
 
   network_configuration_handler_->RemoveConfiguration(
       service_path, NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&TestCallback::Run, base::Unretained(&test_callback)),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, test_callback.run_count());
   EXPECT_FALSE(PendingProfileEntryDeleterForTest(service_path));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Stub based tests
 
 namespace {
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
@@ skipping 34 matching lines @@
     DBusThreadManager::Initialize();
 
     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
     test_observer_.reset(new TestObserver());
     network_state_handler_->AddObserver(test_observer_.get(), FROM_HERE);
 
     network_configuration_handler_.reset(new NetworkConfigurationHandler());
     network_configuration_handler_->Init(network_state_handler_.get(),
                                          NULL /* network_device_handler */);
 
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     test_observer_->ClearPropertyUpdates();
   }
 
   void TearDown() override {
     network_configuration_handler_.reset();
     network_state_handler_->RemoveObserver(test_observer_.get(), FROM_HERE);
     network_state_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
@@ skipping 25 matching lines @@
                                              shill::kStateIdle);
     properties.SetStringWithoutPathExpansion(
         shill::kProfileProperty, NetworkProfileHandler::GetSharedProfilePath());
 
     network_configuration_handler_->CreateShillConfiguration(
         properties, NetworkConfigurationObserver::SOURCE_USER_ACTION,
         base::Bind(
             &NetworkConfigurationHandlerStubTest::CreateConfigurationCallback,
             base::Unretained(this)),
         base::Bind(&ErrorCallback, false, service_path));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
  protected:
   bool GetServiceStringProperty(const std::string& service_path,
                                 const std::string& key,
                                 std::string* result) {
     ShillServiceClient::TestInterface* service_test =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     const base::DictionaryValue* properties =
         service_test->GetServiceProperties(service_path);
@@ skipping 34 matching lines @@
   properties_to_set.SetStringWithoutPathExpansion(shill::kIdentityProperty,
                                                   test_identity);
   properties_to_set.SetStringWithoutPathExpansion(shill::kPassphraseProperty,
                                                   test_passphrase);
   network_configuration_handler_->SetShillProperties(
       service_path, properties_to_set,
       NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&NetworkConfigurationHandlerStubTest::SuccessCallback,
                  base::Unretained(this), "SetProperties"),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ("SetProperties", success_callback_name_);
   std::string identity, passphrase;
   EXPECT_TRUE(GetServiceStringProperty(service_path, shill::kIdentityProperty,
                                        &identity));
   EXPECT_TRUE(GetServiceStringProperty(service_path, shill::kPassphraseProperty,
                                        &passphrase));
   EXPECT_EQ(test_identity, identity);
   EXPECT_EQ(test_passphrase, passphrase);
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(service_path));
 
   // Clear Properties
   std::vector<std::string> properties_to_clear;
   properties_to_clear.push_back(shill::kIdentityProperty);
   properties_to_clear.push_back(shill::kPassphraseProperty);
   network_configuration_handler_->ClearShillProperties(
       service_path, properties_to_clear,
       base::Bind(&NetworkConfigurationHandlerStubTest::SuccessCallback,
                  base::Unretained(this), "ClearProperties"),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ("ClearProperties", success_callback_name_);
   EXPECT_FALSE(GetServiceStringProperty(service_path, shill::kIdentityProperty,
                                         &identity));
   EXPECT_FALSE(GetServiceStringProperty(service_path, shill::kIdentityProperty,
                                         &passphrase));
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(service_path));
 }
 
 TEST_F(NetworkConfigurationHandlerStubTest, StubGetNameFromWifiHex) {
   // TODO(stevenjb): Remove dependency on default Stub service.
   const std::string service_path("/service/wifi1");
   std::string wifi_hex = "5468697320697320484558205353494421";
   std::string expected_name = "This is HEX SSID!";
 
   // Set Properties
   base::DictionaryValue properties_to_set;
   properties_to_set.SetStringWithoutPathExpansion(shill::kWifiHexSsid,
                                                   wifi_hex);
   network_configuration_handler_->SetShillProperties(
       service_path, properties_to_set,
       NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   std::string wifi_hex_result;
   EXPECT_TRUE(GetServiceStringProperty(service_path, shill::kWifiHexSsid,
                                        &wifi_hex_result));
   EXPECT_EQ(wifi_hex, wifi_hex_result);
 
   // Get Properties
   network_configuration_handler_->GetShillProperties(
       service_path,
       base::Bind(&NetworkConfigurationHandlerStubTest::GetPropertiesCallback,
                  base::Unretained(this)),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(service_path, get_properties_path_);
   std::string name_result;
   EXPECT_TRUE(GetReceivedStringProperty(service_path, shill::kNameProperty,
                                         &name_result));
   EXPECT_EQ(expected_name, name_result);
 }
 
 TEST_F(NetworkConfigurationHandlerStubTest, StubCreateConfiguration) {
   const std::string service_path("/service/test_wifi");
@@ skipping 28 matching lines @@
                                   service_path, shill::kTypeProperty));
 
   base::DictionaryValue properties_to_set;
   properties_to_set.SetStringWithoutPathExpansion(shill::kPassphraseProperty,
                                                   test_passphrase);
   network_configuration_handler_->SetShillProperties(
       service_path, properties_to_set,
       NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(test_passphrase, test_observer->GetStringProperty(
                                  service_path, shill::kPassphraseProperty));
 
   std::string user_profile = "/profiles/user1";
   std::string userhash = "user1";
   DBusThreadManager::Get()
       ->GetShillProfileClient()
       ->GetTestInterface()
       ->AddProfile(user_profile, userhash);
 
   network_configuration_handler_->SetNetworkProfile(
       service_path, user_profile,
       NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(test_observer->HasConfiguration(service_path));
   EXPECT_FALSE(test_observer->HasConfigurationInProfile(
       service_path, NetworkProfileHandler::GetSharedProfilePath()));
   EXPECT_TRUE(
       test_observer->HasConfigurationInProfile(service_path, user_profile));
 
   network_configuration_handler_->RemoveConfiguration(
       service_path, NetworkConfigurationObserver::SOURCE_USER_ACTION,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(test_observer->HasConfiguration(service_path));
   EXPECT_FALSE(test_observer->HasConfigurationInProfile(
       service_path, NetworkProfileHandler::GetSharedProfilePath()));
   EXPECT_FALSE(
       test_observer->HasConfigurationInProfile(service_path, user_profile));
 
   network_configuration_handler_->RemoveObserver(test_observer.get());
 }
 
 }  // namespace chromeos