This converts the Shill clients to allow propagation of shill errors

chrome/browser/chromeos/cros/cros_network_functions_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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_network_functions.h"
 #include "chrome/browser/chromeos/cros/sms_watcher.h"
 #include "chromeos/dbus/mock_cashew_client.h"
@@ skipping 174 matching lines @@
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
   }
 
   // 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 GetProperties method calls that return
+  // errors in an error callback.
+  void OnGetPropertiesWithoutStatus(
+      const dbus::ObjectPath& path,
+      const ShillClientHelper::DictionaryValueCallbackWithoutStatus& callback,
+      const ShillClientHelper::ErrorCallback& error_callback) {
+    callback.Run(*dictionary_value_result_);
+  }
+
   // Handles responses for GetEntry method calls.
   void OnGetEntry(
       const dbus::ObjectPath& profile_path,
       const std::string& entry_path,
-      const ShillClientHelper::DictionaryValueCallback& callback) {
-    callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
+      const ShillClientHelper::DictionaryValueCallbackWithoutStatus& callback,
+      const ShillClientHelper::ErrorCallback& error_callback) {
+    callback.Run(*dictionary_value_result_);
   }
 
   // Mock NetworkOperationCallback.
   MOCK_METHOD3(MockNetworkOperationCallback,
                void(const std::string& path,
                     NetworkMethodErrorType error,
                     const std::string& error_message));
 
   // Mock MonitorSMSCallback.
   MOCK_METHOD2(MockMonitorSMSCallback,
@@ skipping 26 matching lines @@
   const std::string property = "property";
   const std::string key1 = "key1";
   const std::string string1 = "string1";
   const std::string key2 = "key2";
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   EXPECT_CALL(*mock_service_client_,
               SetProperty(dbus::ObjectPath(service_path), property,
-                          IsEqualTo(&value), _)).Times(1);
+                          IsEqualTo(&value), _, _)).Times(1);
 
   CrosSetNetworkServiceProperty(service_path, property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosClearNetworkServiceProperty) {
   const std::string service_path = "/";
   const std::string property = "property";
   EXPECT_CALL(*mock_service_client_,
-              ClearProperty(dbus::ObjectPath(service_path), property, _))
+              ClearProperty(dbus::ObjectPath(service_path), property, _, _))
       .Times(1);
 
   CrosClearNetworkServiceProperty(service_path, property);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkDeviceProperty) {
   const std::string device_path = "/";
   const std::string property = "property";
   const bool kBool = true;
   const base::FundamentalValue value(kBool);
   EXPECT_CALL(*mock_device_client_,
               SetProperty(dbus::ObjectPath(device_path), StrEq(property),
-                          IsEqualTo(&value), _)).Times(1);
+                          IsEqualTo(&value), _, _)).Times(1);
 
   CrosSetNetworkDeviceProperty(device_path, property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkIPConfigProperty) {
   const std::string ipconfig_path = "/";
   const std::string property = "property";
   const int kInt = 1234;
   const base::FundamentalValue value(kInt);
   EXPECT_CALL(*mock_ipconfig_client_,
               SetProperty(dbus::ObjectPath(ipconfig_path), property,
                           IsEqualTo(&value), _)).Times(1);
   CrosSetNetworkIPConfigProperty(ipconfig_path, property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkManagerProperty) {
   const std::string property = "property";
   const base::StringValue value("string");
   EXPECT_CALL(*mock_manager_client_,
-              SetProperty(property, IsEqualTo(&value), _)).Times(1);
+              SetProperty(property, IsEqualTo(&value), _, _)).Times(1);
 
   CrosSetNetworkManagerProperty(property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosDeleteServiceFromProfile) {
   const std::string profile_path("/profile/path");
   const std::string service_path("/service/path");
   EXPECT_CALL(*mock_profile_client_,
-              DeleteEntry(dbus::ObjectPath(profile_path), service_path, _))
+              DeleteEntry(dbus::ObjectPath(profile_path), service_path, _, _))
       .Times(1);
   CrosDeleteServiceFromProfile(profile_path, service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestCellularDataPlanUpdate) {
   const std::string modem_service_path = "/modem/service/path";
   EXPECT_CALL(*mock_cashew_client_,
               RequestDataPlansUpdate(modem_service_path)).Times(1);
   CrosRequestCellularDataPlanUpdate(modem_service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorNetworkManagerProperties) {
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
+
   // Start monitoring.
   ShillClientHelper::PropertyChangedHandler handler;
   EXPECT_CALL(*mock_manager_client_, SetPropertyChangedHandler(_))
       .WillOnce(SaveArg<0>(&handler));
   CrosNetworkWatcher* watcher = CrosMonitorNetworkManagerProperties(
       MockNetworkPropertiesWatcherCallback::CreateCallback(
           flimflam::kFlimflamServicePath, key, value));
   // Call callback.
   handler.Run(key, value);
   // Stop monitoring.
@@ skipping 288 matching lines @@
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
-  EXPECT_CALL(*mock_profile_client_,
-              GetProperties(dbus::ObjectPath(profile_path), _)).WillOnce(
-                  Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
+  EXPECT_CALL(
+      *mock_profile_client_,
+      GetProperties(dbus::ObjectPath(profile_path), _, _)).WillOnce(
+          Invoke(this,
+                 &CrosNetworkFunctionsTest::OnGetPropertiesWithoutStatus));
 
   CrosRequestNetworkProfileProperties(
       profile_path,
       MockNetworkPropertiesCallback::CreateCallback(profile_path, result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkProfileEntryProperties) {
   const std::string profile_path = "profile path";
   const std::string profile_entry_path = "profile entry path";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_profile_client_,
-              GetEntry(dbus::ObjectPath(profile_path), profile_entry_path, _))
+              GetEntry(dbus::ObjectPath(profile_path),
+                       profile_entry_path, _, _))
       .WillOnce(Invoke(this, &CrosNetworkFunctionsTest::OnGetEntry));
 
   CrosRequestNetworkProfileEntryProperties(
       profile_path, profile_entry_path,
       MockNetworkPropertiesCallback::CreateCallback(profile_entry_path,
                                                     result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestHiddenWifiNetworkProperties) {
   const std::string ssid = "ssid";
@@ skipping 16 matching lines @@
       flimflam::kTypeProperty,
       base::Value::CreateStringValue(flimflam::kTypeWifi));
   properties.SetWithoutPathExpansion(
       flimflam::kSSIDProperty,
       base::Value::CreateStringValue(ssid));
   properties.SetWithoutPathExpansion(
       flimflam::kSecurityProperty,
       base::Value::CreateStringValue(security));
   // Set expectations.
   const dbus::ObjectPath service_path("/service/path");
-  ObjectPathDBusMethodCallback callback;
-  EXPECT_CALL(*mock_manager_client_, GetService(IsEqualTo(&properties), _))
+  ObjectPathCallbackWithoutStatus callback;
+  EXPECT_CALL(*mock_manager_client_, GetService(IsEqualTo(&properties), _, _))
       .WillOnce(SaveArg<1>(&callback));
   EXPECT_CALL(*mock_service_client_,
               GetProperties(service_path, _)).WillOnce(
                   Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
 
   // Call function.
   CrosRequestHiddenWifiNetworkProperties(
       ssid, security,
       MockNetworkPropertiesCallback::CreateCallback(service_path.value(),
                                                     result));
   // Run callback to invoke GetProperties.
-  callback.Run(DBUS_METHOD_CALL_SUCCESS, service_path);
+  callback.Run(service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestVirtualNetworkProperties) {
   const std::string service_name = "service name";
   const std::string server_hostname = "server hostname";
   const std::string provider_type = "provider type";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
@@ skipping 14 matching lines @@
       base::Value::CreateStringValue(server_hostname));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderTypeProperty,
       base::Value::CreateStringValue(provider_type));
   properties.SetWithoutPathExpansion(
       flimflam::kVPNDomainProperty,
       base::Value::CreateStringValue(service_name));
 
   // Set expectations.
   const dbus::ObjectPath service_path("/service/path");
-  ObjectPathDBusMethodCallback callback;
-  EXPECT_CALL(*mock_manager_client_, GetService(IsEqualTo(&properties), _))
+  ObjectPathCallbackWithoutStatus callback;
+  EXPECT_CALL(*mock_manager_client_, GetService(IsEqualTo(&properties), _, _))
       .WillOnce(SaveArg<1>(&callback));
   EXPECT_CALL(*mock_service_client_,
               GetProperties(service_path, _)).WillOnce(
                   Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
 
   // Call function.
   CrosRequestVirtualNetworkProperties(
       service_name, server_hostname, provider_type,
       MockNetworkPropertiesCallback::CreateCallback(service_path.value(),
                                                     result));
   // Run callback to invoke GetProperties.
-  callback.Run(DBUS_METHOD_CALL_SUCCESS, service_path);
+  callback.Run(service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkServiceDisconnect) {
   const std::string service_path = "/service/path";
   EXPECT_CALL(*mock_service_client_,
-              Disconnect(dbus::ObjectPath(service_path), _)).Times(1);
+              Disconnect(dbus::ObjectPath(service_path), _, _)).Times(1);
   CrosRequestNetworkServiceDisconnect(service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestRemoveNetworkService) {
   const std::string service_path = "/service/path";
   EXPECT_CALL(*mock_service_client_,
-              Remove(dbus::ObjectPath(service_path), _)).Times(1);
+              Remove(dbus::ObjectPath(service_path), _, _)).Times(1);
   CrosRequestRemoveNetworkService(service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkScan) {
   EXPECT_CALL(*mock_manager_client_,
-              RequestScan(flimflam::kTypeWifi, _)).Times(1);
+              RequestScan(flimflam::kTypeWifi, _, _)).Times(1);
   CrosRequestNetworkScan(flimflam::kTypeWifi);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkDeviceEnable) {
   const bool kEnable = true;
   EXPECT_CALL(*mock_manager_client_,
-              EnableTechnology(flimflam::kTypeWifi, _)).Times(1);
+              EnableTechnology(flimflam::kTypeWifi, _, _)).Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kEnable);
 
   const bool kDisable = false;
   EXPECT_CALL(*mock_manager_client_,
-              DisableTechnology(flimflam::kTypeWifi, _)).Times(1);
+              DisableTechnology(flimflam::kTypeWifi, _, _)).Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kDisable);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestRequirePin) {
   const std::string device_path = "/device/path";
   const std::string pin = "123456";
   const bool kRequire = true;
 
   // Set expectations.
   base::Closure callback;
@@ skipping 90 matching lines @@
       base::Bind(&CrosNetworkFunctionsTest::MockNetworkOperationCallback,
                  base::Unretained(this)));
   // Run saved callback.
   callback.Run();
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetOfflineMode) {
   const bool kOffline = true;
   const base::FundamentalValue value(kOffline);
   EXPECT_CALL(*mock_manager_client_, SetProperty(
-      flimflam::kOfflineModeProperty, IsEqualTo(&value), _)).Times(1);
+      flimflam::kOfflineModeProperty, IsEqualTo(&value), _, _)).Times(1);
   CrosSetOfflineMode(kOffline);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosListIPConfigs) {
   const std::string device_path = "/device/path";
   std::string ipconfig_path = "/ipconfig/path";
 
   const IPConfigType kType = IPCONFIG_TYPE_DHCP;
   const std::string address = "address";
   const int kMtu = 123;
@@ skipping 156 matching lines @@
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosConfigureService) {
   const std::string key1 = "key1";
   const std::string string1 = "string1";
   const std::string key2 = "key2";
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
-  EXPECT_CALL(*mock_manager_client_, ConfigureService(IsEqualTo(&value), _))
+  EXPECT_CALL(*mock_manager_client_, ConfigureService(IsEqualTo(&value), _, _))
       .Times(1);
   CrosConfigureService(value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, NetmaskToPrefixLength) {
   // Valid netmasks
   EXPECT_EQ(32, CrosNetmaskToPrefixLength("255.255.255.255"));
   EXPECT_EQ(31, CrosNetmaskToPrefixLength("255.255.255.254"));
   EXPECT_EQ(30, CrosNetmaskToPrefixLength("255.255.255.252"));
   EXPECT_EQ(29, CrosNetmaskToPrefixLength("255.255.255.248"));
@@ skipping 74 matching lines @@
   EXPECT_EQ("192.0.0.0", CrosPrefixLengthToNetmask(2));
   EXPECT_EQ("128.0.0.0", CrosPrefixLengthToNetmask(1));
   EXPECT_EQ("0.0.0.0", CrosPrefixLengthToNetmask(0));
   // Invalid Prefix Lengths
   EXPECT_EQ("", CrosPrefixLengthToNetmask(-1));
   EXPECT_EQ("", CrosPrefixLengthToNetmask(33));
   EXPECT_EQ("", CrosPrefixLengthToNetmask(255));
 }
 
 }  // namespace chromeos