Update uses of Value in chromeos/, cloud_print/, components/, content/ to use the base:: namespace.

components/wifi/fake_wifi_service.cc

 // Copyright 2013 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 "components/wifi/wifi_service.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "components/onc/onc_constants.h"
@@ skipping 70 matching lines @@
       networks_.push_back(network_properties);
     }
   }
 
   virtual void Initialize(
     scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE {}
 
   virtual void UnInitialize() OVERRIDE {}
 
   virtual void GetProperties(const std::string& network_guid,
-                              DictionaryValue* properties,
+                              base::DictionaryValue* properties,
                               std::string* error) OVERRIDE {
     NetworkList::iterator network_properties = FindNetwork(network_guid);
     if (network_properties != networks_.end()) {
       properties->Swap(network_properties->ToValue(false).get());
     } else {
       *error = "Error.DBusFailed";
     }
   }
 
   virtual void GetManagedProperties(const std::string& network_guid,
-                                    DictionaryValue* managed_properties,
+                                    base::DictionaryValue* managed_properties,
                                     std::string* error) OVERRIDE {
     const std::string network_properties =
         "{"
         "  \"ConnectionState\": {"
         "    \"Active\": \"NotConnected\","
         "    \"Effective\": \"Unmanaged\""
         "  },"
         "  \"GUID\": \"stub_wifi2\","
         "  \"Name\": {"
         "    \"Active\": \"wifi2_PSK\","
@@ skipping 32 matching lines @@
         "      \"Active\": \"WPA-PSK\","
         "      \"Effective\": \"UserPolicy\","
         "      \"UserPolicy\": \"WPA-PSK\""
         "    },"
         "    \"SignalStrength\": {"
         "      \"Active\": 80,"
         "      \"Effective\": \"Unmanaged\""
         "    }"
         "  }"
         "}";
-    scoped_ptr<DictionaryValue> properties_value(
-        reinterpret_cast<DictionaryValue*>(
+    scoped_ptr<base::DictionaryValue> properties_value(
+        reinterpret_cast<base::DictionaryValue*>(
             base::JSONReader::Read(network_properties)));
     managed_properties->MergeDictionary(properties_value.get());
   }
 
   virtual void GetState(const std::string& network_guid,
-                        DictionaryValue* properties,
+                        base::DictionaryValue* properties,
                         std::string* error) OVERRIDE {
     NetworkList::iterator network_properties = FindNetwork(network_guid);
     if (network_properties == networks_.end()) {
       *error = "Error.InvalidParameter";
       return;
     }
 
     const std::string network_state =
         "{"
         "  \"ConnectionState\": \"NotConnected\","
         "  \"GUID\": \"stub_wifi2\","
         "  \"Name\": \"wifi2_PSK\","
         "  \"Type\": \"WiFi\","
         "  \"WiFi\": {"
         "    \"Security\": \"WPA-PSK\","
         "    \"SignalStrength\": 80"
         "  }"
         "}";
-    scoped_ptr<DictionaryValue> properties_value(
-        reinterpret_cast<DictionaryValue*>(
+    scoped_ptr<base::DictionaryValue> properties_value(
+        reinterpret_cast<base::DictionaryValue*>(
             base::JSONReader::Read(network_state)));
     properties->MergeDictionary(properties_value.get());
   }
 
   virtual void SetProperties(const std::string& network_guid,
                              scoped_ptr<base::DictionaryValue> properties,
                              std::string* error) OVERRIDE {
     NetworkList::iterator network_properties = FindNetwork(network_guid);
     if (network_properties == networks_.end() ||
         !network_properties->UpdateFromValue(*properties)) {
       *error = "Error.DBusFailed";
     }
   }
 
   virtual void CreateNetwork(bool shared,
                              scoped_ptr<base::DictionaryValue> properties,
                              std::string* network_guid,
                              std::string* error) OVERRIDE {
     WiFiService::NetworkProperties network_properties;
     if (network_properties.UpdateFromValue(*properties)) {
       network_properties.guid = network_properties.ssid;
       networks_.push_back(network_properties);
       *network_guid = network_properties.guid;
     } else {
       *error = "Error.DBusFailed";
     }
   }
 
   virtual void GetVisibleNetworks(const std::string& network_type,
-                                  ListValue* network_list) OVERRIDE {
+                                  base::ListValue* network_list) OVERRIDE {
     for (WiFiService::NetworkList::const_iterator it = networks_.begin();
          it != networks_.end();
          ++it) {
       if (network_type.empty() ||
           network_type == onc::network_type::kAllTypes ||
           it->type == network_type) {
-        scoped_ptr<DictionaryValue> network(it->ToValue(true));
+        scoped_ptr<base::DictionaryValue> network(it->ToValue(true));
         network_list->Append(network.release());
       }
     }
   }
 
   virtual void RequestNetworkScan() OVERRIDE {
     NotifyNetworkListChanged(networks_);
   }
 
   virtual void StartConnect(const std::string& network_guid,
@@ skipping 79 matching lines @@
 
   NetworkList networks_;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   NetworkGuidListCallback networks_changed_observer_;
   NetworkGuidListCallback network_list_changed_observer_;
 };
 
 WiFiService* WiFiService::CreateForTest() { return new FakeWiFiService(); }
 
 }  // namespace wifi