Deprecate ShillNetworkClient and add GeolocationHandler

chromeos/network/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 "chromeos/dbus/mock_dbus_thread_manager.h"
 #include "chromeos/dbus/mock_gsm_sms_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/network/cros_network_functions.h"
 #include "chromeos/network/sms_watcher.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;
@@ skipping 82 matching lines @@
     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_device_client_ =
         mock_dbus_thread_manager->mock_shill_device_client();
     mock_ipconfig_client_ =
         mock_dbus_thread_manager->mock_shill_ipconfig_client();
     mock_manager_client_ =
         mock_dbus_thread_manager->mock_shill_manager_client();
-    mock_network_client_ =
-        mock_dbus_thread_manager->mock_shill_network_client();
     mock_profile_client_ =
         mock_dbus_thread_manager->mock_shill_profile_client();
     mock_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;
@@ skipping 37 matching lines @@
                     const std::string& error_message));
 
   // Mock MonitorSMSCallback.
   MOCK_METHOD2(MockMonitorSMSCallback,
                void(const std::string& modem_device_path, const SMS& message));
 
  protected:
   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_,
@@ skipping 672 matching lines @@
   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());
   EXPECT_EQ(ipconfig_path, result_ipconfig_paths[0]);
 }
 
-TEST_F(CrosNetworkFunctionsTest, CrosGetWifiAccessPoints) {
-  const std::string device_path = "/device/path";
-  base::ListValue* devices = new base::ListValue;
-  devices->Append(new base::StringValue(device_path));
-  base::DictionaryValue* manager_properties = new base::DictionaryValue;
-  manager_properties->SetWithoutPathExpansion(
-      flimflam::kDevicesProperty, devices);
-
-  const int kScanInterval = 42;
-  const std::string network_path = "/network/path";
-  base::ListValue* networks = new base::ListValue;
-  networks->Append(new base::StringValue(network_path));
-  base::DictionaryValue* device_properties = new base::DictionaryValue;
-  device_properties->SetWithoutPathExpansion(
-      flimflam::kNetworksProperty, networks);
-  device_properties->SetWithoutPathExpansion(
-      flimflam::kPoweredProperty, base::Value::CreateBooleanValue(true));
-  device_properties->SetWithoutPathExpansion(
-      flimflam::kScanIntervalProperty,
-      base::Value::CreateIntegerValue(kScanInterval));
-
-  const int kSignalStrength = 10;
-  const int kWifiChannel = 3;
-  const std::string address = "address";
-  const std::string name = "name";
-  const base::Time expected_timestamp =
-      base::Time::Now() - base::TimeDelta::FromSeconds(kScanInterval);
-  const base::TimeDelta acceptable_timestamp_range =
-      base::TimeDelta::FromSeconds(1);
-
-  base::DictionaryValue* network_properties = new base::DictionaryValue;
-  network_properties->SetWithoutPathExpansion(
-      flimflam::kAddressProperty, new base::StringValue(address));
-  network_properties->SetWithoutPathExpansion(
-      flimflam::kNameProperty, new base::StringValue(name));
-  network_properties->SetWithoutPathExpansion(
-      flimflam::kSignalStrengthProperty,
-      base::Value::CreateIntegerValue(kSignalStrength));
-  network_properties->SetWithoutPathExpansion(
-      flimflam::kWifiChannelProperty,
-      base::Value::CreateIntegerValue(kWifiChannel));
-
-  // Set expectations.
-  EXPECT_CALL(*mock_manager_client_, CallGetPropertiesAndBlock())
-      .WillOnce(Return(manager_properties));
-  EXPECT_CALL(*mock_device_client_,
-              CallGetPropertiesAndBlock(dbus::ObjectPath(device_path)))
-      .WillOnce(Return(device_properties));
-  EXPECT_CALL(*mock_network_client_,
-              CallGetPropertiesAndBlock(dbus::ObjectPath(network_path)))
-      .WillOnce(Return(network_properties));
-
-  // Call function.
-  WifiAccessPointVector aps;
-  ASSERT_TRUE(CrosGetWifiAccessPoints(&aps));
-  ASSERT_EQ(1U, aps.size());
-  EXPECT_EQ(address, aps[0].mac_address);
-  EXPECT_EQ(name, aps[0].name);
-  EXPECT_LE(expected_timestamp - acceptable_timestamp_range, aps[0].timestamp);
-  EXPECT_GE(expected_timestamp + acceptable_timestamp_range, aps[0].timestamp);
-  EXPECT_EQ(kSignalStrength, aps[0].signal_strength);
-  EXPECT_EQ(kWifiChannel, aps[0].channel);
-}
-
 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), _, _))
       .Times(1);
   CrosConfigureService(value);
 }
 
 }  // namespace chromeos