Prevent networkingPrivate.forgetNetwork from removing shared configs

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"
@@ skipping 47 matching lines @@
 
 void DictionaryValueCallback(const std::string& expected_id,
                              const std::string& expected_json,
                              const std::string& service_path,
                              const base::DictionaryValue& dictionary) {
   std::string dict_str = PrettyJson(dictionary);
   EXPECT_EQ(expected_json, dict_str);
   EXPECT_EQ(expected_id, service_path);
 }
 
-void ErrorCallback(bool error_expected,
-                   const std::string& expected_id,
-                   const std::string& error_name,
+void ErrorCallback(const std::string& error_name,
                    std::unique_ptr<base::DictionaryValue> error_data) {
-  EXPECT_TRUE(error_expected) << "Unexpected error: " << error_name
-                              << " with associated data: \n"
-                              << PrettyJson(*error_data);
+  ADD_FAILURE() << "Unexpected error: " << error_name
+                << " with associated data: \n"
+                << PrettyJson(*error_data);
+}
+
+void RecordError(std::string* error_name_ptr,
+                 const std::string& error_name,
+                 std::unique_ptr<base::DictionaryValue> error_data) {
+  *error_name_ptr = error_name;
 }
 
 void ServiceResultCallback(const std::string& expected_result,
                            const std::string& service_path,
                            const std::string& guid) {
   EXPECT_EQ(expected_result, service_path);
 }
 
 void DBusErrorCallback(const std::string& error_name,
                        const std::string& error_message) {
@@ skipping 102 matching lines @@
     mock_profile_client_ = new MockShillProfileClient();
     mock_service_client_ = new MockShillServiceClient();
     dbus_setter->SetShillManagerClient(
         std::unique_ptr<ShillManagerClient>(mock_manager_client_));
     dbus_setter->SetShillProfileClient(
         std::unique_ptr<ShillProfileClient>(mock_profile_client_));
     dbus_setter->SetShillServiceClient(
         std::unique_ptr<ShillServiceClient>(mock_service_client_));
 
     EXPECT_CALL(*mock_service_client_, GetProperties(_, _)).Times(AnyNumber());
+    EXPECT_CALL(*mock_service_client_, AddPropertyChangedObserver(_, _))
+        .Times(AnyNumber());
+    EXPECT_CALL(*mock_service_client_, RemovePropertyChangedObserver(_, _))
+        .Times(AnyNumber());
     EXPECT_CALL(*mock_manager_client_, GetProperties(_)).Times(AnyNumber());
     EXPECT_CALL(*mock_manager_client_, AddPropertyChangedObserver(_))
-        .Times(AnyNumber());
+        .WillRepeatedly(Invoke(
+            this,
+            &NetworkConfigurationHandlerTest::AddPropertyChangedObserver));
     EXPECT_CALL(*mock_manager_client_, RemovePropertyChangedObserver(_))
-        .Times(AnyNumber());
+        .WillRepeatedly(Invoke(
+            this,
+            &NetworkConfigurationHandlerTest::RemovePropertyChangedObserver));
 
     network_state_handler_ = NetworkStateHandler::InitializeForTest();
     network_configuration_handler_.reset(new NetworkConfigurationHandler());
     network_configuration_handler_->Init(network_state_handler_.get(),
                                          NULL /* network_device_handler */);
     base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override {
     network_state_handler_->Shutdown();
     network_configuration_handler_.reset();
     network_state_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
+  void AddPropertyChangedObserver(ShillPropertyChangedObserver* observer) {
+    property_changed_observers_.AddObserver(observer);
+  }
+
+  void RemovePropertyChangedObserver(ShillPropertyChangedObserver* observer) {
+    property_changed_observers_.RemoveObserver(observer);
+  }
+
   // Handles responses for GetProperties method calls.
   void OnGetProperties(
       const dbus::ObjectPath& path,
       const ShillClientHelper::DictionaryValueCallback& callback) {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
   }
 
   // Handles responses for SetProperties method calls.
   void OnSetProperties(const dbus::ObjectPath& service_path,
                        const base::DictionaryValue& properties,
@@ skipping 24 matching lines @@
     result.AppendBoolean(false);
     callback.Run(result);
   }
 
   void OnConfigureService(
       const dbus::ObjectPath& profile_path,
       const base::DictionaryValue& properties,
       const ObjectPathCallback& callback,
       const ShillClientHelper::ErrorCallback& error_callback) {
     callback.Run(dbus::ObjectPath("/service/2"));
+
+    // Notify property changed observer that service list was changed - the
+    // goal is to have network state handler update it's network state list.
+    base::ListValue value;
+    value.AppendString("/service/1");
+    value.AppendString("/service/2");
+    for (auto& observer : property_changed_observers_) {
+      observer.OnPropertyChanged("ServiceCompleteList", value);
+    }
   }
 
   void OnGetLoadableProfileEntries(
       const dbus::ObjectPath& service_path,
       const ShillClientHelper::DictionaryValueCallback& callback) {
     base::DictionaryValue entries;
     entries.SetString("profile1", "entry1");
     entries.SetString("profile2", "entry2");
     callback.Run(DBUS_METHOD_CALL_SUCCESS, entries);
   }
 
   void OnDeleteEntry(const dbus::ObjectPath& profile_path,
                      const std::string& entry_path,
                      const base::Closure& callback,
                      const ShillClientHelper::ErrorCallback& error_callback) {
     // Don't run the callback immediately to emulate actual behavior.
     message_loop_.task_runner()->PostTask(FROM_HERE, callback);
   }
 
   bool PendingProfileEntryDeleterForTest(const std::string& service_path) {
     return network_configuration_handler_->PendingProfileEntryDeleterForTest(
         service_path);
   }
 
   void CreateConfiguration(const std::string& service_path,
                            const base::DictionaryValue& properties) {
     network_configuration_handler_->CreateShillConfiguration(
         properties, NetworkConfigurationObserver::SOURCE_USER_ACTION,
         base::Bind(&ServiceResultCallback, service_path),
-        base::Bind(&ErrorCallback, false, std::string()));
+        base::Bind(&ErrorCallback));
   }
 
  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_;
   base::DictionaryValue* dictionary_value_result_;
+
+  base::ObserverList<ShillPropertyChangedObserver, true>
+      property_changed_observers_;
 };
 
 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::Value> networkNameValue(new base::Value(networkName));
 
   base::DictionaryValue value;
   value.Set(key, new base::Value(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));
   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));
+      base::Bind(&ErrorCallback));
   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::Value> networkNameValue(new base::Value(networkName));
 
   base::DictionaryValue value;
   value.Set(key, new base::Value(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));
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallback));
   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::Value> networkNameValue(new base::Value(networkName));
 
   // First set up a value to clear.
   base::DictionaryValue value;
   value.Set(key, new base::Value(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));
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallback));
   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));
+      base::Bind(&ErrorCallback));
   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::Value> networkNameValue(new base::Value(networkName));
 
   // First set up a value to clear.
   base::DictionaryValue value;
   value.Set(key, new base::Value(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));
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallback));
   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));
+
+  std::string error;
   network_configuration_handler_->ClearShillProperties(
       service_path, values_to_clear, base::Bind(&base::DoNothing),
-      base::Bind(&ErrorCallback, true, service_path));
+      base::Bind(&ErrorCallback));
   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::Value(type));
   value.SetWithoutPathExpansion(shill::kProfileProperty,
                                 new base::Value(profile));
 
   EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(dbus::ObjectPath(profile), _, _, _))
       .WillOnce(
           Invoke(this, &NetworkConfigurationHandlerTest::OnConfigureService));
   CreateConfiguration("/service/2", value);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, RemoveConfiguration) {
-  std::string service_path = "/service/1";
+  std::string service_path = "/service/2";
+
+  // Set up network configuration so the associated network service has the
+  // profile path set to |profile|.
+  std::string key = "SSID";
+  std::string type = "wifi";
+  base::DictionaryValue value;
+  shill_property_util::SetSSID("Service", &value);
+  value.SetWithoutPathExpansion(shill::kTypeProperty, new base::Value(type));
+  value.SetWithoutPathExpansion(shill::kProfileProperty,
+                                new base::Value("profile2"));
+  EXPECT_CALL(*mock_manager_client_,
+              ConfigureServiceForProfile(dbus::ObjectPath("profile2"), _, _, _))
+      .WillOnce(
+          Invoke(this, &NetworkConfigurationHandlerTest::OnConfigureService));
+
+  dictionary_value_result_ = &value;
+  EXPECT_CALL(*mock_service_client_, GetProperties(_, _))
+      .WillRepeatedly(
+          Invoke(this, &NetworkConfigurationHandlerTest::OnGetProperties));
+
+  CreateConfiguration(service_path, value);
+  base::RunLoop().RunUntilIdle();
+
+  // Set Up mock flor GetLoadableProfileEntries - it returns
+  // [(profile1, entry1), (profile2, entry2)] profile-entry pairs.
+  EXPECT_CALL(*mock_service_client_,
+              GetLoadableProfileEntries(dbus::ObjectPath(service_path), _))
+      .WillOnce(Invoke(
+          this, &NetworkConfigurationHandlerTest::OnGetLoadableProfileEntries));
+
+  // Expectations for entries deleted during the test.
+  EXPECT_CALL(*mock_profile_client_,
+              DeleteEntry(dbus::ObjectPath("profile1"), "entry1", _, _))
+      .WillOnce(Invoke(this, &NetworkConfigurationHandlerTest::OnDeleteEntry));
+  EXPECT_CALL(*mock_profile_client_,
+              DeleteEntry(dbus::ObjectPath("profile2"), "entry2", _, _))
+      .WillOnce(Invoke(this, &NetworkConfigurationHandlerTest::OnDeleteEntry));
 
   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));
+      base::Bind(&ErrorCallback));
+
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, test_callback.run_count());
   EXPECT_FALSE(PendingProfileEntryDeleterForTest(service_path));
 }
 
+TEST_F(NetworkConfigurationHandlerTest, RemoveConfigurationFromCurrentProfile) {
+  std::string service_path = "/service/2";
+
+  // Set up network configuration so the associated network service has the
+  // profile path set to |profile|.
+  std::string key = "SSID";
+  std::string type = "wifi";
+  base::DictionaryValue value;
+  shill_property_util::SetSSID("Service", &value);
+  value.SetWithoutPathExpansion(shill::kTypeProperty, new base::Value(type));
+  value.SetWithoutPathExpansion(shill::kProfileProperty,
+                                new base::Value("profile2"));
+  EXPECT_CALL(*mock_manager_client_,
+              ConfigureServiceForProfile(dbus::ObjectPath("profile2"), _, _, _))
+      .WillOnce(
+          Invoke(this, &NetworkConfigurationHandlerTest::OnConfigureService));
+
+  dictionary_value_result_ = &value;
+  EXPECT_CALL(*mock_service_client_, GetProperties(_, _))
+      .WillRepeatedly(
+          Invoke(this, &NetworkConfigurationHandlerTest::OnGetProperties));
+
+  CreateConfiguration(service_path, value);
+  base::RunLoop().RunUntilIdle();
+
+  // Set Up mock flor GetLoadableProfileEntries - it returns
+  // [(profile1, entry1), (profile2, entry2)] profile-entry pairs.
+  EXPECT_CALL(*mock_service_client_,
+              GetLoadableProfileEntries(dbus::ObjectPath(service_path), _))
+      .WillOnce(Invoke(
+          this, &NetworkConfigurationHandlerTest::OnGetLoadableProfileEntries));
+
+  // Expectations for entries deleted during the test.
+  EXPECT_CALL(*mock_profile_client_,
+              DeleteEntry(dbus::ObjectPath("profile2"), "entry2", _, _))
+      .WillOnce(Invoke(this, &NetworkConfigurationHandlerTest::OnDeleteEntry));
+  EXPECT_CALL(*mock_profile_client_,
+              DeleteEntry(dbus::ObjectPath("profile1"), "entry1", _, _))
+      .Times(0);
+
+  TestCallback test_callback;
+  network_configuration_handler_->RemoveConfigurationFromCurrentProfile(
+      service_path, NetworkConfigurationObserver::SOURCE_USER_ACTION,
+      base::Bind(&TestCallback::Run, base::Unretained(&test_callback)),
+      base::Bind(&ErrorCallback));
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(1, test_callback.run_count());
+  EXPECT_FALSE(PendingProfileEntryDeleterForTest(service_path));
+}
+
+TEST_F(NetworkConfigurationHandlerTest,
+       RemoveNonExistentConfigurationFromCurrentProfile) {
+  // Set Up mock flor GetLoadableProfileEntries - it returns
+  // [(profile1, entry1), (profile2, entry2)] profile-entry pairs.
+  EXPECT_CALL(*mock_service_client_,
+              GetLoadableProfileEntries(dbus::ObjectPath("/service/3"), _))
+      .WillRepeatedly(Invoke(
+          this, &NetworkConfigurationHandlerTest::OnGetLoadableProfileEntries));
+
+  // Expectations for entries deleted during the test.
+  EXPECT_CALL(*mock_profile_client_,
+              DeleteEntry(dbus::ObjectPath("profile2"), "entry2", _, _))
+      .Times(0);
+  EXPECT_CALL(*mock_profile_client_,
+              DeleteEntry(dbus::ObjectPath("profile1"), "entry1", _, _))
+      .Times(0);
+
+  TestCallback test_callback;
+  std::string error;
+  network_configuration_handler_->RemoveConfigurationFromCurrentProfile(
+      "/service/3", NetworkConfigurationObserver::SOURCE_USER_ACTION,
+      base::Bind(&TestCallback::Run, base::Unretained(&test_callback)),
+      base::Bind(&RecordError, base::Unretained(&error)));
+  EXPECT_EQ("NetworkNotConfigured", error);
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(0, test_callback.run_count());
+  EXPECT_FALSE(PendingProfileEntryDeleterForTest("/service/3"));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Stub based tests
 
 namespace {
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   TestObserver() : network_list_changed_count_(0) {}
   ~TestObserver() override {}
 
@@ skipping 76 matching lines @@
     properties.SetStringWithoutPathExpansion(shill::kStateProperty,
                                              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));
+        base::Bind(&ErrorCallback));
     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 =
@@ skipping 34 matching lines @@
   base::DictionaryValue properties_to_set;
   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));
+      base::Bind(&ErrorCallback));
   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));
+      base::Bind(&ErrorCallback));
   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));
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallback));
   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));
+      base::Bind(&ErrorCallback));
   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) {
@@ skipping 27 matching lines @@
       service_path, NetworkProfileHandler::GetSharedProfilePath()));
   EXPECT_EQ(shill::kTypeWifi, test_observer->GetStringProperty(
                                   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));
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallback));
   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));
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallback));
   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));
+      base::Bind(&base::DoNothing), base::Bind(&ErrorCallback));
   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