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

components/autofill/content/browser/wallet/wallet_items.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/autofill/content/browser/wallet/wallet_items.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 137 matching lines @@
     DLOG(ERROR) << "Response from Google Wallet missing status";
     return scoped_ptr<MaskedInstrument>();
   }
 
   std::string object_id;
   if (!dictionary.GetString("object_id", &object_id)) {
     DLOG(ERROR) << "Response from Google Wallet missing object id";
     return scoped_ptr<MaskedInstrument>();
   }
 
-  const DictionaryValue* address_dict;
+  const base::DictionaryValue* address_dict;
   if (!dictionary.GetDictionary("billing_address", &address_dict)) {
     DLOG(ERROR) << "Response from Google wallet missing address";
     return scoped_ptr<MaskedInstrument>();
   }
   scoped_ptr<Address> address = Address::CreateDisplayAddress(*address_dict);
 
   if (!address) {
     DLOG(ERROR) << "Response from Google wallet contained malformed address";
     return scoped_ptr<MaskedInstrument>();
   }
 
   std::vector<base::string16> supported_currencies;
-  const ListValue* supported_currency_list;
+  const base::ListValue* supported_currency_list;
   if (dictionary.GetList("supported_currency", &supported_currency_list)) {
     for (size_t i = 0; i < supported_currency_list->GetSize(); ++i) {
       base::string16 currency;
       if (supported_currency_list->GetString(i, &currency))
         supported_currencies.push_back(currency);
     }
   } else {
     DVLOG(1) << "Response from Google Wallet missing supported currency";
   }
 
@@ skipping 248 matching lines @@
       default_instrument_id_(default_instrument_id),
       default_address_id_(default_address_id),
       active_account_index_(std::numeric_limits<size_t>::max()),
       amex_permission_(amex_permission) {}
 
 WalletItems::~WalletItems() {}
 
 scoped_ptr<WalletItems>
     WalletItems::CreateWalletItems(const base::DictionaryValue& dictionary) {
   std::vector<RequiredAction> required_action;
-  const ListValue* required_action_list;
+  const base::ListValue* required_action_list;
   if (dictionary.GetList("required_action", &required_action_list)) {
     for (size_t i = 0; i < required_action_list->GetSize(); ++i) {
       std::string action_string;
       if (required_action_list->GetString(i, &action_string)) {
         RequiredAction action = ParseRequiredActionFromString(action_string);
         if (!ActionAppliesToWalletItems(action)) {
           DLOG(ERROR) << "Response from Google wallet with bad required action:"
                          " \"" << action_string << "\"";
           return scoped_ptr<WalletItems>();
         }
@@ skipping 43 matching lines @@
 
       scoped_ptr<GaiaAccount> gaia_account(
           GaiaAccount::Create(*account_dict));
       if (gaia_account)
         wallet_items->AddAccount(gaia_account.Pass());
     }
   } else {
     DVLOG(1) << "Response from Google wallet missing GAIA accounts";
   }
 
-  const ListValue* legal_docs;
+  const base::ListValue* legal_docs;
   if (dictionary.GetList("required_legal_document", &legal_docs)) {
     for (size_t i = 0; i < legal_docs->GetSize(); ++i) {
-      const DictionaryValue* legal_doc_dict;
+      const base::DictionaryValue* legal_doc_dict;
       if (legal_docs->GetDictionary(i, &legal_doc_dict)) {
         scoped_ptr<LegalDocument> legal_doc(
             LegalDocument::CreateLegalDocument(*legal_doc_dict));
         if (legal_doc)
           wallet_items->AddLegalDocument(legal_doc.Pass());
         else
           return scoped_ptr<WalletItems>();
       }
     }
 
     if (!legal_docs->empty()) {
       // Always append the privacy policy link as well.
       wallet_items->AddLegalDocument(
           LegalDocument::CreatePrivacyPolicyDocument());
     }
   } else {
     DVLOG(1) << "Response from Google wallet missing legal docs";
   }
 
-  const ListValue* instruments;
+  const base::ListValue* instruments;
   if (dictionary.GetList("instrument", &instruments)) {
     for (size_t i = 0; i < instruments->GetSize(); ++i) {
-      const DictionaryValue* instrument_dict;
+      const base::DictionaryValue* instrument_dict;
       if (instruments->GetDictionary(i, &instrument_dict)) {
         scoped_ptr<MaskedInstrument> instrument(
             MaskedInstrument::CreateMaskedInstrument(*instrument_dict));
         if (instrument)
           wallet_items->AddInstrument(instrument.Pass());
       }
     }
   } else {
     DVLOG(1) << "Response from Google wallet missing instruments";
   }
 
-  const ListValue* addresses;
+  const base::ListValue* addresses;
   if (dictionary.GetList("address", &addresses)) {
     for (size_t i = 0; i < addresses->GetSize(); ++i) {
-      const DictionaryValue* address_dict;
+      const base::DictionaryValue* address_dict;
       if (addresses->GetDictionary(i, &address_dict)) {
         scoped_ptr<Address> address(
             Address::CreateAddressWithID(*address_dict));
         if (address)
           wallet_items->AddAddress(address.Pass());
       }
     }
   } else {
     DVLOG(1) << "Response from Google wallet missing addresses";
   }
@@ skipping 29 matching lines @@
          VectorsAreEqual<LegalDocument>(legal_documents(),
                                          other.legal_documents());
 }
 
 bool WalletItems::operator!=(const WalletItems& other) const {
   return !(*this == other);
 }
 
 }  // namespace wallet
 }  // namespace autofill