Add copy and assignment to FundamentalValue and StringValue.

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 383 matching lines @@
   data_plan->update_time = base::Time::FromInternalValue(kUpdateTime);
   data_plan->plan_start_time = base::Time::FromInternalValue(kPlanStartTime);
   data_plan->plan_end_time = base::Time::FromInternalValue(kPlanEndTime);
   data_plan->plan_data_bytes = 1024*1024;
   data_plan->data_bytes_used = 12345;
   data_plans.push_back(data_plan);
 
   base::DictionaryValue* data_plan_dictionary = new base::DictionaryValue;
   data_plan_dictionary->SetWithoutPathExpansion(
       cashew::kCellularPlanNameProperty,
-      base::Value::CreateStringValue(data_plan->plan_name));
+      new base::StringValue(data_plan->plan_name));
   data_plan_dictionary->SetWithoutPathExpansion(
       cashew::kCellularPlanTypeProperty,
-      base::Value::CreateStringValue(cashew::kCellularDataPlanMeteredPaid));
+      new base::StringValue(cashew::kCellularDataPlanMeteredPaid));
   data_plan_dictionary->SetWithoutPathExpansion(
       cashew::kCellularPlanUpdateTimeProperty,
       base::Value::CreateDoubleValue(kUpdateTime));
   data_plan_dictionary->SetWithoutPathExpansion(
       cashew::kCellularPlanStartProperty,
       base::Value::CreateDoubleValue(kPlanStartTime));
   data_plan_dictionary->SetWithoutPathExpansion(
       cashew::kCellularPlanEndProperty,
       base::Value::CreateDoubleValue(kPlanEndTime));
   data_plan_dictionary->SetWithoutPathExpansion(
@@ skipping 24 matching lines @@
   EXPECT_CALL(*mock_cashew_client_, ResetDataPlansUpdateHandler()).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorSMS) {
   const std::string dbus_connection = ":1.1";
   const dbus::ObjectPath object_path("/object/path");
   base::DictionaryValue device_properties;
   device_properties.SetWithoutPathExpansion(
       flimflam::kDBusConnectionProperty,
-      base::Value::CreateStringValue(dbus_connection));
+      new base::StringValue(dbus_connection));
   device_properties.SetWithoutPathExpansion(
       flimflam::kDBusObjectProperty,
-      base::Value::CreateStringValue(object_path.value()));
+      new base::StringValue(object_path.value()));
 
   const std::string number = "0123456789";
   const std::string text = "Hello.";
   const std::string timestamp_string =
       "120424123456+00";  // 2012-04-24 12:34:56
   base::Time::Exploded timestamp_exploded = {};
   timestamp_exploded.year = 2012;
   timestamp_exploded.month = 4;
   timestamp_exploded.day_of_month = 24;
   timestamp_exploded.hour = 12;
   timestamp_exploded.minute = 34;
   timestamp_exploded.second = 56;
   const base::Time timestamp = base::Time::FromUTCExploded(timestamp_exploded);
   const std::string smsc = "9876543210";
   const uint32 kValidity = 1;
   const uint32 kMsgclass = 2;
   const uint32 kIndex = 0;
   const bool kComplete = true;
   base::DictionaryValue* sms_dictionary = new base::DictionaryValue;
   sms_dictionary->SetWithoutPathExpansion(
-      SMSWatcher::kNumberKey, base::Value::CreateStringValue(number));
+      SMSWatcher::kNumberKey, new base::StringValue(number));
   sms_dictionary->SetWithoutPathExpansion(
-      SMSWatcher::kTextKey, base::Value::CreateStringValue(text));
+      SMSWatcher::kTextKey, new base::StringValue(text));
   sms_dictionary->SetWithoutPathExpansion(
       SMSWatcher::kTimestampKey,
-      base::Value::CreateStringValue(timestamp_string));
+      new base::StringValue(timestamp_string));
   sms_dictionary->SetWithoutPathExpansion(SMSWatcher::kSmscKey,
-                                         base::Value::CreateStringValue(smsc));
+                                         new base::StringValue(smsc));
   sms_dictionary->SetWithoutPathExpansion(
       SMSWatcher::kValidityKey, base::Value::CreateDoubleValue(kValidity));
   sms_dictionary->SetWithoutPathExpansion(
       SMSWatcher::kClassKey, base::Value::CreateDoubleValue(kMsgclass));
   sms_dictionary->SetWithoutPathExpansion(
       SMSWatcher::kIndexKey, base::Value::CreateDoubleValue(kIndex));
 
   base::ListValue sms_list;
   sms_list.Append(sms_dictionary);
 
@@ skipping 62 matching lines @@
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkManagerProperties) {
   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));
+  result.SetWithoutPathExpansion(key1, new base::StringValue(value1));
+  result.SetWithoutPathExpansion(key2, new base::StringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_manager_client_,
               GetProperties(_)).WillOnce(
                   Invoke(this,
                          &CrosNetworkFunctionsTest::OnGetManagerProperties));
 
   CrosRequestNetworkManagerProperties(
       MockNetworkPropertiesCallback::CreateCallback(
           flimflam::kFlimflamServicePath, result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkServiceProperties) {
   const std::string service_path = "/service/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));
+  result.SetWithoutPathExpansion(key1, new base::StringValue(value1));
+  result.SetWithoutPathExpansion(key2, new base::StringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_service_client_,
               GetProperties(dbus::ObjectPath(service_path), _)).WillOnce(
                   Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
 
   CrosRequestNetworkServiceProperties(
       service_path,
       MockNetworkPropertiesCallback::CreateCallback(service_path, result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkDeviceProperties) {
   const std::string device_path = "/device/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));
+  result.SetWithoutPathExpansion(key1, new base::StringValue(value1));
+  result.SetWithoutPathExpansion(key2, new base::StringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_device_client_,
               GetProperties(dbus::ObjectPath(device_path), _)).WillOnce(
                   Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
 
   CrosRequestNetworkDeviceProperties(
       device_path,
       MockNetworkPropertiesCallback::CreateCallback(device_path, result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkProfileProperties) {
   const std::string profile_path = "/profile/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));
+  result.SetWithoutPathExpansion(key1, new base::StringValue(value1));
+  result.SetWithoutPathExpansion(key2, new base::StringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   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));
+  result.SetWithoutPathExpansion(key1, new base::StringValue(value1));
+  result.SetWithoutPathExpansion(key2, new base::StringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_profile_client_,
               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";
   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));
+  result.SetWithoutPathExpansion(key1, new base::StringValue(value1));
+  result.SetWithoutPathExpansion(key2, new base::StringValue(value2));
   dictionary_value_result_ = &result;
   // Create expected argument to ShillManagerClient::GetService.
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(
       flimflam::kModeProperty,
-      base::Value::CreateStringValue(flimflam::kModeManaged));
+      new base::StringValue(flimflam::kModeManaged));
   properties.SetWithoutPathExpansion(
       flimflam::kTypeProperty,
-      base::Value::CreateStringValue(flimflam::kTypeWifi));
+      new base::StringValue(flimflam::kTypeWifi));
   properties.SetWithoutPathExpansion(
       flimflam::kSSIDProperty,
-      base::Value::CreateStringValue(ssid));
+      new base::StringValue(ssid));
   properties.SetWithoutPathExpansion(
       flimflam::kSecurityProperty,
-      base::Value::CreateStringValue(security));
+      new base::StringValue(security));
   // Set expectations.
   const dbus::ObjectPath service_path("/service/path");
   ObjectPathCallback 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(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";
   // Create result value.
   base::DictionaryValue result;
-  result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
-  result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
+  result.SetWithoutPathExpansion(key1, new base::StringValue(value1));
+  result.SetWithoutPathExpansion(key2, new base::StringValue(value2));
   dictionary_value_result_ = &result;
   // Create expected argument to ShillManagerClient::GetService.
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(
-      flimflam::kTypeProperty, base::Value::CreateStringValue("vpn"));
+      flimflam::kTypeProperty, new base::StringValue("vpn"));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderNameProperty,
-      base::Value::CreateStringValue(service_name));
+      new base::StringValue(service_name));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderHostProperty,
-      base::Value::CreateStringValue(server_hostname));
+      new base::StringValue(server_hostname));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderTypeProperty,
-      base::Value::CreateStringValue(provider_type));
+      new base::StringValue(provider_type));
   properties.SetWithoutPathExpansion(
       flimflam::kVPNDomainProperty,
-      base::Value::CreateStringValue(service_name));
+      new base::StringValue(service_name));
 
   // Set expectations.
   const dbus::ObjectPath service_path("/service/path");
   ObjectPathCallback 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));
 
@@ skipping 161 matching lines @@
   const std::string broadcast = "broadcast";
   const std::string peer_address = "peer address";
   const std::string gateway = "gateway";
   const std::string domainname = "domainname";
   const std::string name_server1 = "nameserver1";
   const std::string name_server2 = "nameserver2";
   const std::string name_servers = name_server1 + "," + name_server2;
   const std::string hardware_address = "hardware address";
 
   base::ListValue* ipconfigs = new base::ListValue;
-  ipconfigs->Append(base::Value::CreateStringValue(ipconfig_path));
+  ipconfigs->Append(new base::StringValue(ipconfig_path));
   base::DictionaryValue* device_properties = new base::DictionaryValue;
   device_properties->SetWithoutPathExpansion(
       flimflam::kIPConfigsProperty, ipconfigs);
   device_properties->SetWithoutPathExpansion(
       flimflam::kAddressProperty,
-      base::Value::CreateStringValue(hardware_address));
+      new base::StringValue(hardware_address));
 
   base::ListValue* name_servers_list = new base::ListValue;
-  name_servers_list->Append(base::Value::CreateStringValue(name_server1));
-  name_servers_list->Append(base::Value::CreateStringValue(name_server2));
+  name_servers_list->Append(new base::StringValue(name_server1));
+  name_servers_list->Append(new base::StringValue(name_server2));
   base::DictionaryValue* ipconfig_properties = new base::DictionaryValue;
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kMethodProperty,
-      base::Value::CreateStringValue(flimflam::kTypeDHCP));
+      new base::StringValue(flimflam::kTypeDHCP));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kAddressProperty,
-      base::Value::CreateStringValue(address));
+      new base::StringValue(address));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kMtuProperty,
       base::Value::CreateIntegerValue(kMtu));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kPrefixlenProperty,
       base::Value::CreateIntegerValue(kPrefixlen));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kBroadcastProperty,
-      base::Value::CreateStringValue(broadcast));
+      new base::StringValue(broadcast));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kPeerAddressProperty,
-      base::Value::CreateStringValue(peer_address));
+      new base::StringValue(peer_address));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kGatewayProperty,
-      base::Value::CreateStringValue(gateway));
+      new base::StringValue(gateway));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kDomainNameProperty,
-      base::Value::CreateStringValue(domainname));
+      new base::StringValue(domainname));
   ipconfig_properties->SetWithoutPathExpansion(
       flimflam::kNameServersProperty, name_servers_list);
 
   EXPECT_CALL(*mock_device_client_,
               CallGetPropertiesAndBlock(dbus::ObjectPath(device_path)))
       .WillOnce(Return(device_properties));
   EXPECT_CALL(*mock_ipconfig_client_,
               CallGetPropertiesAndBlock(dbus::ObjectPath(ipconfig_path)))
       .WillOnce(Return(ipconfig_properties));
 
@@ skipping 14 matching lines @@
   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(base::Value::CreateStringValue(device_path));
+  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(base::Value::CreateStringValue(network_path));
+  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, base::Value::CreateStringValue(address));
+      flimflam::kAddressProperty, new base::StringValue(address));
   network_properties->SetWithoutPathExpansion(
-      flimflam::kNameProperty, base::Value::CreateStringValue(name));
+      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));
@@ skipping 112 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