Renaming instances of "flimflam" with "shill", now that we're only

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"
 #include "chromeos/dbus/mock_dbus_thread_manager.h"
-#include "chromeos/dbus/mock_flimflam_device_client.h"
-#include "chromeos/dbus/mock_flimflam_ipconfig_client.h"
-#include "chromeos/dbus/mock_flimflam_manager_client.h"
-#include "chromeos/dbus/mock_flimflam_network_client.h"
-#include "chromeos/dbus/mock_flimflam_profile_client.h"
-#include "chromeos/dbus/mock_flimflam_service_client.h"
+#include "chromeos/dbus/mock_shill_device_client.h"
+#include "chromeos/dbus/mock_shill_ipconfig_client.h"
+#include "chromeos/dbus/mock_shill_manager_client.h"
+#include "chromeos/dbus/mock_shill_network_client.h"
+#include "chromeos/dbus/mock_shill_profile_client.h"
+#include "chromeos/dbus/mock_shill_service_client.h"
 #include "chromeos/dbus/mock_gsm_sms_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrEq;
@@ skipping 125 matching lines @@
   CrosNetworkFunctionsTest() : mock_profile_client_(NULL),
                                dictionary_value_result_(NULL) {}
 
   virtual void SetUp() {
     MockDBusThreadManager* mock_dbus_thread_manager = new MockDBusThreadManager;
     EXPECT_CALL(*mock_dbus_thread_manager, GetSystemBus())
         .WillRepeatedly(Return(reinterpret_cast<dbus::Bus*>(NULL)));
     DBusThreadManager::InitializeForTesting(mock_dbus_thread_manager);
     mock_cashew_client_ = mock_dbus_thread_manager->mock_cashew_client();
     mock_device_client_ =
-        mock_dbus_thread_manager->mock_flimflam_device_client();
+        mock_dbus_thread_manager->mock_shill_device_client();
     mock_ipconfig_client_ =
-        mock_dbus_thread_manager->mock_flimflam_ipconfig_client();
+        mock_dbus_thread_manager->mock_shill_ipconfig_client();
     mock_manager_client_ =
-        mock_dbus_thread_manager->mock_flimflam_manager_client();
+        mock_dbus_thread_manager->mock_shill_manager_client();
     mock_network_client_ =
-        mock_dbus_thread_manager->mock_flimflam_network_client();
+        mock_dbus_thread_manager->mock_shill_network_client();
     mock_profile_client_ =
-        mock_dbus_thread_manager->mock_flimflam_profile_client();
+        mock_dbus_thread_manager->mock_shill_profile_client();
     mock_service_client_ =
-        mock_dbus_thread_manager->mock_flimflam_service_client();
+        mock_dbus_thread_manager->mock_shill_service_client();
     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 FlimflamManagerClient.
+  // Handles responses for GetProperties method calls for ShillManagerClient.
   void OnGetManagerProperties(
-      const FlimflamClientHelper::DictionaryValueCallback& callback) {
+      const ShillClientHelper::DictionaryValueCallback& callback) {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
   }
 
   // Handles responses for GetProperties method calls.
   void OnGetProperties(
       const dbus::ObjectPath& path,
-      const FlimflamClientHelper::DictionaryValueCallback& callback) {
+      const ShillClientHelper::DictionaryValueCallback& callback) {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
   }
 
   // Handles responses for GetEntry method calls.
   void OnGetEntry(
       const dbus::ObjectPath& profile_path,
       const std::string& entry_path,
-      const FlimflamClientHelper::DictionaryValueCallback& callback) {
+      const ShillClientHelper::DictionaryValueCallback& callback) {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *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,
                void(const std::string& modem_device_path, const SMS& message));
 
  protected:
   MockCashewClient* mock_cashew_client_;
-  MockFlimflamDeviceClient* mock_device_client_;
-  MockFlimflamIPConfigClient* mock_ipconfig_client_;
-  MockFlimflamManagerClient* mock_manager_client_;
-  MockFlimflamNetworkClient* mock_network_client_;
-  MockFlimflamProfileClient* mock_profile_client_;
-  MockFlimflamServiceClient* mock_service_client_;
+  MockShillDeviceClient* mock_device_client_;
+  MockShillIPConfigClient* mock_ipconfig_client_;
+  MockShillManagerClient* mock_manager_client_;
+  MockShillNetworkClient* mock_network_client_;
+  MockShillProfileClient* mock_profile_client_;
+  MockShillServiceClient* mock_service_client_;
   MockGsmSMSClient* mock_gsm_sms_client_;
   const base::DictionaryValue* dictionary_value_result_;
 };
 
 TEST_F(CrosNetworkFunctionsTest, CrosActivateCellularModem) {
   const std::string service_path = "/";
   const std::string carrier = "carrier";
   EXPECT_CALL(*mock_service_client_,
               CallActivateCellularModemAndBlock(dbus::ObjectPath(service_path),
                                                 carrier))
@@ skipping 74 matching lines @@
   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.
-  FlimflamClientHelper::PropertyChangedHandler handler;
+  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.
   EXPECT_CALL(*mock_manager_client_, ResetPropertyChangedHandler()).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorNetworkServiceProperties) {
   const dbus::ObjectPath path("/path");
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
   // Start monitoring.
-  FlimflamClientHelper::PropertyChangedHandler handler;
+  ShillClientHelper::PropertyChangedHandler handler;
   EXPECT_CALL(*mock_service_client_, SetPropertyChangedHandler(path, _))
       .WillOnce(SaveArg<1>(&handler));
   NetworkPropertiesWatcherCallback callback =
       MockNetworkPropertiesWatcherCallback::CreateCallback(path.value(),
                                                            key, value);
   CrosNetworkWatcher* watcher = CrosMonitorNetworkServiceProperties(
       callback, path.value());
   // Call callback.
   handler.Run(key, value);
   // Stop monitoring.
   EXPECT_CALL(*mock_service_client_,
               ResetPropertyChangedHandler(path)).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorNetworkDeviceProperties) {
   const dbus::ObjectPath path("/path");
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
   // Start monitoring.
-  FlimflamClientHelper::PropertyChangedHandler handler;
+  ShillClientHelper::PropertyChangedHandler handler;
   EXPECT_CALL(*mock_device_client_, SetPropertyChangedHandler(path, _))
       .WillOnce(SaveArg<1>(&handler));
   NetworkPropertiesWatcherCallback callback =
       MockNetworkPropertiesWatcherCallback::CreateCallback(path.value(),
                                                            key, value);
   CrosNetworkWatcher* watcher = CrosMonitorNetworkDeviceProperties(
       callback, path.value());
   // Call callback.
   handler.Run(key, value);
   // Stop monitoring.
@@ skipping 116 matching lines @@
   sms.timestamp = timestamp;
   sms.number = number.c_str();
   sms.text = text.c_str();
   sms.smsc = smsc.c_str();
   sms.validity = kValidity;
   sms.msgclass = kMsgclass;
 
   const std::string modem_device_path = "/modem/device/path";
 
   // Set expectations.
-  FlimflamDeviceClient::DictionaryValueCallback get_properties_callback;
+  ShillDeviceClient::DictionaryValueCallback get_properties_callback;
   EXPECT_CALL(*mock_device_client_,
               GetProperties(dbus::ObjectPath(modem_device_path), _))
       .WillOnce(SaveArg<1>(&get_properties_callback));
   GsmSMSClient::SmsReceivedHandler sms_received_handler;
   EXPECT_CALL(*mock_gsm_sms_client_,
               SetSmsReceivedHandler(dbus_connection, object_path, _))
       .WillOnce(SaveArg<2>(&sms_received_handler));
 
   GsmSMSClient::ListCallback list_callback;
   EXPECT_CALL(*mock_gsm_sms_client_, List(dbus_connection, object_path, _))
@@ skipping 152 matching lines @@
   const std::string security = "security";
   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));
   dictionary_value_result_ = &result;
-  // Create expected argument to FlimflamManagerClient::GetService.
+  // Create expected argument to ShillManagerClient::GetService.
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(
       flimflam::kModeProperty,
       base::Value::CreateStringValue(flimflam::kModeManaged));
   properties.SetWithoutPathExpansion(
       flimflam::kTypeProperty,
       base::Value::CreateStringValue(flimflam::kTypeWifi));
   properties.SetWithoutPathExpansion(
       flimflam::kSSIDProperty,
       base::Value::CreateStringValue(ssid));
@@ skipping 24 matching lines @@
   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";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   dictionary_value_result_ = &result;
-  // Create expected argument to FlimflamManagerClient::GetService.
+  // Create expected argument to ShillManagerClient::GetService.
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(
       flimflam::kTypeProperty, base::Value::CreateStringValue("vpn"));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderNameProperty,
       base::Value::CreateStringValue(service_name));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderHostProperty,
       base::Value::CreateStringValue(server_hostname));
   properties.SetWithoutPathExpansion(
@@ skipping 425 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