Move base/values.h into the base namespace.

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "third_party/cros/chromeos_network.h"
 
+namespace base {
 class DictionaryValue;
 class Value;
+}
 
 namespace chromeos {
 
 // Connection enums (see flimflam/include/service.h)
 enum ConnectionType {
   TYPE_UNKNOWN   = 0,
   TYPE_ETHERNET  = 1,
   TYPE_WIFI      = 2,
   TYPE_WIMAX     = 3,
   TYPE_BLUETOOTH = 4,
@@ skipping 203 matching lines @@
   const std::string& selected_cellular_network() const {
     return selected_cellular_network_;
   }
   const CellularNetworkList& found_cellular_networks() const {
     return found_cellular_networks_;
   }
   bool data_roaming_allowed() const { return data_roaming_allowed_; }
   bool support_network_scan() const { return support_network_scan_; }
 
  private:
-  bool ParseValue(int index, const Value* value);
-  void ParseInfo(const DictionaryValue* info);
+  bool ParseValue(int index, const base::Value* value);
+  void ParseInfo(const base::DictionaryValue* info);
 
   // General device info.
   std::string device_path_;
   std::string name_;
   ConnectionType type_;
   bool scanning_;
   // Cellular specific device info.
   std::string carrier_;
   std::string home_provider_;
   std::string home_provider_code_;
@@ skipping 100 matching lines @@
   }
 
   // Sends the well-known TPM PIN to flimflam via D-Bus, because flimflam may
   // need it to access client certificates in the TPM for 802.1X, VPN, etc.
   void SendTpmPin(const std::string& tpm_pin);
 
  protected:
   Network(const std::string& service_path, ConnectionType type);
 
   // Parse name/value pairs from libcros.
-  virtual bool ParseValue(int index, const Value* value);
-  virtual void ParseInfo(const DictionaryValue* info);
+  virtual bool ParseValue(int index, const base::Value* value);
+  virtual void ParseInfo(const base::DictionaryValue* info);
 
   // Erase cached credentials, used when "Save password" is unchecked.
   virtual void EraseCredentials();
 
   // Calculate a unique identifier for the network.
   virtual void CalculateUniqueId();
 
   // Methods to asynchronously set network service properties
   virtual void SetStringProperty(const char* prop, const std::string& str,
                                  std::string* dest);
   virtual void SetBooleanProperty(const char* prop, bool b, bool* dest);
   virtual void SetIntegerProperty(const char* prop, int i, int* dest);
-  virtual void SetValueProperty(const char* prop, Value* val);
+  virtual void SetValueProperty(const char* prop, base::Value* val);
   virtual void ClearProperty(const char* prop);
 
   // This will clear the property if string is empty. Otherwise, it will set it.
   virtual void SetOrClearStringProperty(const char* prop,
                                         const std::string& str,
                                         std::string* dest);
 
   std::string device_path_;
   std::string name_;
   std::string ip_address_;
@@ skipping 103 matching lines @@
 
   // Public setters.
   void SetCACertNSS(const std::string& ca_cert_nss);
   void SetPSKPassphrase(const std::string& psk_passphrase);
   void SetClientCertID(const std::string& cert_id);
   void SetUsername(const std::string& username);
   void SetUserPassphrase(const std::string& user_passphrase);
 
  private:
   // Network overrides.
-  virtual bool ParseValue(int index, const Value* value);
-  virtual void ParseInfo(const DictionaryValue* info);
+  virtual bool ParseValue(int index, const base::Value* value);
+  virtual void ParseInfo(const base::DictionaryValue* info);
   virtual void EraseCredentials();
   virtual void CalculateUniqueId();
 
   // VirtualNetwork private methods.
-  bool ParseProviderValue(int index, const Value* value);
+  bool ParseProviderValue(int index, const base::Value* value);
 
   void set_server_hostname(const std::string& server_hostname) {
     server_hostname_ = server_hostname;
   }
   void set_provider_type(ProviderType provider_type) {
     provider_type_ = provider_type;
   }
   void set_ca_cert_nss(const std::string& ca_cert_nss) {
     ca_cert_nss_ = ca_cert_nss;
   }
@@ skipping 30 matching lines @@
  public:
   int strength() const { return strength_; }
 
  protected:
   WirelessNetwork(const std::string& service_path, ConnectionType type)
       : Network(service_path, type),
         strength_(0) {}
   int strength_;
 
   // Network overrides.
-  virtual bool ParseValue(int index, const Value* value);
+  virtual bool ParseValue(int index, const base::Value* value);
 
  private:
   void set_strength(int strength) { strength_ = strength; }
 
   friend class NetworkLibraryImpl;
   friend class NetworkLibraryStubImpl;
   DISALLOW_COPY_AND_ASSIGN(WirelessNetwork);
 };
 
 // Class for networks of TYPE_CELLULAR.
@@ skipping 12 matching lines @@
   struct Apn {
     std::string apn;
     std::string network_id;
     std::string username;
     std::string password;
 
     Apn();
     Apn(const std::string& apn, const std::string& network_id,
         const std::string& username, const std::string& password);
     ~Apn();
-    void Set(const DictionaryValue& dict);
+    void Set(const base::DictionaryValue& dict);
   };
 
   explicit CellularNetwork(const std::string& service_path);
   virtual ~CellularNetwork();
 
   // Starts device activation process. Returns false if the device state does
   // not permit activation.
   bool StartActivation() const;
   // Requests data plans if the network is conencted and activated.
   // Plan data will be passed through Network::Observer::CellularDataPlanChanged
@@ skipping 41 matching lines @@
   // Return a string representation of activation state.
   std::string GetActivationStateString() const;
   // Return a string representation of roaming state.
   std::string GetRoamingStateString() const;
 
   // Return a string representation of |activation_state|.
   static std::string ActivationStateToString(ActivationState activation_state);
 
  protected:
   // WirelessNetwork overrides.
-  virtual bool ParseValue(int index, const Value* value);
+  virtual bool ParseValue(int index, const base::Value* value);
 
   ActivationState activation_state_;
   NetworkTechnology network_technology_;
   NetworkRoamingState roaming_state_;
   // Carrier Info
   std::string operator_name_;
   std::string operator_code_;
   std::string operator_country_;
   std::string payment_url_;
   std::string usage_url_;
@@ skipping 72 matching lines @@
 
   // Return true if a passphrase or other input is required to connect.
   bool IsPassphraseRequired() const;
 
  private:
   // Network overrides.
   virtual void EraseCredentials();
   virtual void CalculateUniqueId();
 
   // WirelessNetwork overrides.
-  virtual bool ParseValue(int index, const Value* value);
+  virtual bool ParseValue(int index, const base::Value* value);
 
   void set_encryption(ConnectionSecurity encryption) {
     encryption_ = encryption;
   }
   void set_passphrase(const std::string& passphrase) {
     passphrase_ = passphrase;
   }
   void set_passphrase_required(bool passphrase_required) {
     passphrase_required_ = passphrase_required;
   }
@@ skipping 473 matching lines @@
   virtual void SetIPConfig(const NetworkIPConfig& ipconfig) = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_