more changes

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/network_library.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 
@@ skipping 1268 matching lines @@
   DCHECK(prop);
   if (!EnsureCrosLoaded())
     return;
   chromeos::ClearNetworkServiceProperty(service_path_.c_str(), prop);
 }
 
 void Network::SetStringProperty(
     const char* prop, const std::string& str, std::string* dest) {
   if (dest)
     *dest = str;
-  scoped_ptr<Value> value(Value::CreateStringValue(str));
+  scoped_ptr<Value> value(base::StringValue::New(str));
   SetValueProperty(prop, value.get());
 }
 
 void Network::SetOrClearStringProperty(const char* prop,
                                        const std::string& str,
                                        std::string* dest) {
   if (str.empty()) {
     ClearProperty(prop);
     if (dest)
       dest->clear();
   } else {
     SetStringProperty(prop, str, dest);
   }
 }
 
 void Network::SetBooleanProperty(const char* prop, bool b, bool* dest) {
   if (dest)
     *dest = b;
-  scoped_ptr<Value> value(Value::CreateBooleanValue(b));
+  scoped_ptr<Value> value(base::BooleanValue::New(b));
   SetValueProperty(prop, value.get());
 }
 
 void Network::SetIntegerProperty(const char* prop, int i, int* dest) {
   if (dest)
     *dest = i;
-  scoped_ptr<Value> value(Value::CreateIntegerValue(i));
+  scoped_ptr<Value> value(base::NumberValue::New(i));
   SetValueProperty(prop, value.get());
 }
 
 void Network::SetPreferred(bool preferred) {
   if (preferred) {
     SetIntegerProperty(kPriorityProperty, kPriorityPreferred, &priority_);
   } else {
     ClearProperty(kPriorityProperty);
     priority_ = kPriorityNotSet;
   }
@@ skipping 3409 matching lines @@
   // but not UI doesn't assume such notification so just ignore result.
 }
 
 void NetworkLibraryImplCros::SetCellularDataRoamingAllowed(bool new_value) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling SetCellularDataRoamingAllowed method "
         "w/o cellular device.";
     return;
   }
-  scoped_ptr<Value> value(Value::CreateBooleanValue(new_value));
+  scoped_ptr<Value> value(base::BooleanValue::New(new_value));
   chromeos::SetNetworkDeviceProperty(cellular->device_path().c_str(),
                                      kCellularAllowRoamingProperty,
                                      value.get());
 }
 
 void NetworkLibraryImplCros::RequestNetworkScan() {
   if (wifi_enabled()) {
     wifi_scanning_ = true;  // Cleared when updates are received.
     chromeos::RequestNetworkScan(kTypeWifi);
   }
@@ skipping 125 matching lines @@
       if (ipconfig_status2) {
         for (int i = 0; i < ipconfig_status2->size; ++i) {
           if (ipconfig_status2->ips[i].type == chromeos::IPCONFIG_TYPE_IPV4)
             ipconfig_static = &ipconfig_status2->ips[i];
         }
       }
     }
     if (ipconfig_static) {
       // Save any changed details.
       if (ipconfig.address != ipconfig_static->address) {
-        scoped_ptr<Value> value(Value::CreateStringValue(ipconfig.address));
+        scoped_ptr<Value> value(base::StringValue::New(ipconfig.address));
         chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
                                              kAddressProperty,
                                              value.get());
       }
       if (ipconfig.netmask != ipconfig_static->netmask) {
         int32 prefixlen = ipconfig.GetPrefixLength();
         if (prefixlen == -1) {
           VLOG(1) << "IP config prefixlen is invalid for netmask "
                   << ipconfig.netmask;
         } else {
-          scoped_ptr<Value> value(Value::CreateIntegerValue(prefixlen));
+          scoped_ptr<Value> value(base::NumberValue::New(prefixlen));
           chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
                                                kPrefixlenProperty,
                                                value.get());
         }
       }
       if (ipconfig.gateway != ipconfig_static->gateway) {
-        scoped_ptr<Value> value(Value::CreateStringValue(ipconfig.gateway));
+        scoped_ptr<Value> value(base::StringValue::New(ipconfig.gateway));
         chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
                                              kGatewayProperty,
                                              value.get());
       }
       if (ipconfig.name_servers != ipconfig_static->name_servers) {
         scoped_ptr<Value> value(
-            Value::CreateStringValue(ipconfig.name_servers));
+            base::StringValue::New(ipconfig.name_servers));
         chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
                                              kNameServersProperty,
                                              value.get());
       }
       // Remove dhcp ip config if there is one.
       if (ipconfig_dhcp)
         chromeos::RemoveIPConfig(ipconfig_dhcp);
     }
   }
 
@@ skipping 679 matching lines @@
   is_locked_ = false;
 
   // Devices
   int devices =
       (1 << TYPE_ETHERNET) | (1 << TYPE_WIFI) | (1 << TYPE_CELLULAR);
   available_devices_ = devices;
   enabled_devices_ = devices;
   connected_devices_ = devices;
 
   NetworkDevice* cellular = new NetworkDevice("cellular");
-  scoped_ptr<Value> cellular_type(Value::CreateStringValue(kTypeCellular));
+  scoped_ptr<Value> cellular_type(base::StringValue::New(kTypeCellular));
   cellular->ParseValue(PROPERTY_INDEX_TYPE, cellular_type.get());
   cellular->IMSI_ = "123456789012345";
   device_map_["cellular"] = cellular;
 
   // Networks
   DeleteNetworks();
 
   ethernet_ = new EthernetNetwork("eth1");
   ethernet_->set_connected(true);
   AddNetwork(ethernet_);
@@ skipping 246 matching lines @@
   return network_library;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);