This is the first pass at making GetIPConfigs asynchronous.

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 36 matching lines @@
 
 const char kExamplePath[] = "/foo/bar/baz";
 
 // A mock to check arguments of NetworkPropertiesCallback and ensure that the
 // callback is called exactly once.
 class MockNetworkPropertiesCallback {
  public:
   // Creates a NetworkPropertiesCallback with expectations.
   static NetworkPropertiesCallback CreateCallback(
       const std::string& expected_path,
-      const base::DictionaryValue& expected_result) {
+      base::DictionaryValue& expected_result) {
     MockNetworkPropertiesCallback* mock_callback =
         new MockNetworkPropertiesCallback;
 
     EXPECT_CALL(*mock_callback,
-                Run(expected_path, Pointee(IsEqualTo(&expected_result))))
+                RunMock(expected_path, Pointee(IsEqualTo(&expected_result))))
         .Times(1);
 
     return base::Bind(&MockNetworkPropertiesCallback::Run,
                       base::Owned(mock_callback));
   }
 
-  MOCK_METHOD2(Run, void(const std::string& path,
-                         const base::DictionaryValue* result));
+  // We have to implement this as a non-mock and call the mock function because
+  // mocks don't play well with scoped_ptr arguments because they are movable
+  // but not copyable.  Expectations are placed on the RunMock function instead.
+  void Run(const std::string& path,
+           scoped_ptr<base::DictionaryValue> result) {
+    RunMock(path, result.get());
+  }
+
+  MOCK_METHOD2(RunMock, void(const std::string& path,
+                             base::DictionaryValue* result));
 };
 
 // A mock to check arguments of NetworkPropertiesWatcherCallback and ensure that
 // the callback is called exactly once.
 class MockNetworkPropertiesWatcherCallback {
  public:
   // Creates a NetworkPropertiesWatcherCallback with expectations.
   static NetworkPropertiesWatcherCallback CreateCallback(
       const std::string& expected_path,
       const std::string& expected_key,
@@ skipping 93 matching lines @@
     mock_gsm_sms_client_ = mock_dbus_thread_manager->mock_gsm_sms_client();
   }
 
   virtual void TearDown() {
     DBusThreadManager::Shutdown();
     mock_profile_client_ = NULL;
   }
 
   // Handles responses for GetProperties method calls for ShillManagerClient.
   void OnGetManagerProperties(
-      const ShillClientHelper::DictionaryValueCallback& callback) {
-    callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
+       const ShillClientHelper::DictionaryValueCallback& callback) {
+    scoped_ptr<base::DictionaryValue> result_copy(
+        dictionary_value_result_->DeepCopy());
+    callback.Run(DBUS_METHOD_CALL_SUCCESS, result_copy.Pass());
   }
 
   // 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_);
+    scoped_ptr<base::DictionaryValue> result_copy(
+        dictionary_value_result_->DeepCopy());
+    callback.Run(DBUS_METHOD_CALL_SUCCESS, result_copy.Pass());
   }
 
   // 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_);
+    scoped_ptr<base::DictionaryValue> result_copy(
+        dictionary_value_result_->DeepCopy());
+    callback.Run(result_copy.Pass());
   }
 
   // Handles responses for GetEntry method calls.
   void OnGetEntry(
       const dbus::ObjectPath& profile_path,
       const std::string& entry_path,
       const ShillClientHelper::DictionaryValueCallbackWithoutStatus& callback,
       const ShillClientHelper::ErrorCallback& error_callback) {
-    callback.Run(*dictionary_value_result_);
+    scoped_ptr<base::DictionaryValue> result_copy(
+        dictionary_value_result_->DeepCopy());
+    callback.Run(result_copy.Pass());
   }
 
   // Mock NetworkOperationCallback.
   MOCK_METHOD3(MockNetworkOperationCallback,
                void(const std::string& path,
                     NetworkMethodErrorType error,
                     const std::string& error_message));
 
   // Mock MonitorSMSCallback.
   MOCK_METHOD2(MockMonitorSMSCallback,
@@ skipping 306 matching lines @@
   EXPECT_CALL(*mock_gsm_sms_client_,
               Get(dbus_connection, object_path, kIndex, _))
       .WillOnce(SaveArg<3>(&get_callback));
 
   // Start monitoring.
   CrosNetworkWatcher* watcher = CrosMonitorSMS(
       modem_device_path,
       base::Bind(&CrosNetworkFunctionsTest::MockMonitorSMSCallback,
                  base::Unretained(this)));
   // Return GetProperties() result.
-  get_properties_callback.Run(DBUS_METHOD_CALL_SUCCESS, device_properties);
+  scoped_ptr<base::DictionaryValue> properties_copy(
+      device_properties.DeepCopy());
+  get_properties_callback.Run(DBUS_METHOD_CALL_SUCCESS, properties_copy.Pass());
   // Return List() result.
   ASSERT_FALSE(list_callback.is_null());
   list_callback.Run(sms_list);
   // Return Delete() result.
   ASSERT_FALSE(delete_callback.is_null());
   delete_callback.Run();
   // Send fake signal.
   ASSERT_FALSE(sms_received_handler.is_null());
   sms_received_handler.Run(kIndex, kComplete);
   // Return Get() result.
@@ skipping 346 matching lines @@
 }
 
 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);
   CrosSetOfflineMode(kOffline);
 }
 
-TEST_F(CrosNetworkFunctionsTest, CrosListIPConfigs) {
+TEST_F(CrosNetworkFunctionsTest, CrosListIPConfigsAndBlock) {
   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;
   const int kPrefixlen = 24;
   const std::string netmask = "255.255.255.0";
   const std::string broadcast = "broadcast";
   const std::string peer_address = "peer address";
@@ skipping 48 matching lines @@
               CallGetPropertiesAndBlock(dbus::ObjectPath(device_path)))
       .WillOnce(Return(device_properties));
   EXPECT_CALL(*mock_ipconfig_client_,
               CallGetPropertiesAndBlock(dbus::ObjectPath(ipconfig_path)))
       .WillOnce(Return(ipconfig_properties));
 
   NetworkIPConfigVector result_ipconfigs;
   std::vector<std::string> result_ipconfig_paths;
   std::string result_hardware_address;
   EXPECT_TRUE(
-      CrosListIPConfigs(device_path, &result_ipconfigs, &result_ipconfig_paths,
-                        &result_hardware_address));
+      CrosListIPConfigsAndBlock(device_path,
+                                &result_ipconfigs,
+                                &result_ipconfig_paths,
+                                &result_hardware_address));
 
   EXPECT_EQ(hardware_address, result_hardware_address);
   ASSERT_EQ(1U, result_ipconfigs.size());
   EXPECT_EQ(device_path, result_ipconfigs[0].device_path);
   EXPECT_EQ(kType, result_ipconfigs[0].type);
   EXPECT_EQ(address, result_ipconfigs[0].address);
   EXPECT_EQ(netmask, result_ipconfigs[0].netmask);
   EXPECT_EQ(gateway, result_ipconfigs[0].gateway);
   EXPECT_EQ(name_servers, result_ipconfigs[0].name_servers);
   ASSERT_EQ(1U, result_ipconfig_paths.size());
@@ skipping 177 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