Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/chromeos/contacts/gdata_contacts_service.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 "chrome/browser/chromeos/contacts/gdata_contacts_service.h"
 
 #include <cstring>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 138 matching lines @@
 // Returns a string containing a pretty-printed JSON representation of |value|.
 std::string PrettyPrintValue(const base::Value& value) {
   std::string out;
   base::JSONWriter::WriteWithOptions(
       &value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &out);
   return out;
 }
 
 // Assigns the value at |path| within |dict| to |out|, returning false if the
 // path wasn't present.  Unicode byte order marks are removed from the string.
-bool GetCleanedString(const DictionaryValue& dict,
+bool GetCleanedString(const base::DictionaryValue& dict,
                       const std::string& path,
                       std::string* out) {
   if (!dict.GetString(path, out))
     return false;
 
   // The Unicode byte order mark, U+FEFF, is useless in UTF-8 strings (which are
   // interpreted one byte at a time).
   ReplaceSubstringsAfterOffset(out, 0, "\xEF\xBB\xBF", "");
   return true;
 }
 
 // Returns whether an address is primary, given a dictionary representing a
 // single address.
-bool IsAddressPrimary(const DictionaryValue& address_dict) {
+bool IsAddressPrimary(const base::DictionaryValue& address_dict) {
   std::string primary;
   address_dict.GetString(kAddressPrimaryField, &primary);
   return primary == kAddressPrimaryTrueValue;
 }
 
 // Initializes an AddressType message given a dictionary representing a single
 // address.
-void InitAddressType(const DictionaryValue& address_dict,
+void InitAddressType(const base::DictionaryValue& address_dict,
                      Contact_AddressType* type) {
   DCHECK(type);
   type->Clear();
 
   std::string rel;
   address_dict.GetString(kAddressRelField, &rel);
   if (rel == kAddressRelHomeValue)
     type->set_relation(Contact_AddressType_Relation_HOME);
   else if (rel == kAddressRelWorkValue)
     type->set_relation(Contact_AddressType_Relation_WORK);
   else if (rel == kAddressRelMobileValue)
     type->set_relation(Contact_AddressType_Relation_MOBILE);
   else
     type->set_relation(Contact_AddressType_Relation_OTHER);
 
   GetCleanedString(address_dict, kAddressLabelField, type->mutable_label());
 }
 
 // Maps the protocol from a dictionary representing a contact's IM address to a
 // contacts::Contact_InstantMessagingAddress_Protocol value.
 contacts::Contact_InstantMessagingAddress_Protocol
-GetInstantMessagingProtocol(const DictionaryValue& im_dict) {
+GetInstantMessagingProtocol(const base::DictionaryValue& im_dict) {
   std::string protocol;
   im_dict.GetString(kInstantMessagingProtocolField, &protocol);
   if (protocol == kInstantMessagingProtocolAimValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_AIM;
   else if (protocol == kInstantMessagingProtocolMsnValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_MSN;
   else if (protocol == kInstantMessagingProtocolYahooValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_YAHOO;
   else if (protocol == kInstantMessagingProtocolSkypeValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_SKYPE;
   else if (protocol == kInstantMessagingProtocolQqValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_QQ;
   else if (protocol == kInstantMessagingProtocolGoogleTalkValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_GOOGLE_TALK;
   else if (protocol == kInstantMessagingProtocolIcqValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_ICQ;
   else if (protocol == kInstantMessagingProtocolJabberValue)
     return contacts::Contact_InstantMessagingAddress_Protocol_JABBER;
   else
     return contacts::Contact_InstantMessagingAddress_Protocol_OTHER;
 }
 
 // Gets the photo URL from a contact's dictionary (within the "entry" list).
 // Returns an empty string if no photo was found.
-std::string GetPhotoUrl(const DictionaryValue& dict) {
-  const ListValue* link_list = NULL;
+std::string GetPhotoUrl(const base::DictionaryValue& dict) {
+  const base::ListValue* link_list = NULL;
   if (!dict.GetList(kLinkField, &link_list))
     return std::string();
 
   for (size_t i = 0; i < link_list->GetSize(); ++i) {
-    const DictionaryValue* link_dict = NULL;
+    const base::DictionaryValue* link_dict = NULL;
     if (!link_list->GetDictionary(i, &link_dict))
       continue;
 
     std::string rel;
     if (!link_dict->GetString(kLinkRelField, &rel))
       continue;
     if (rel != kLinkRelPhotoValue)
       continue;
 
     // From https://goo.gl/7T6Od: "If a contact does not have a photo, then the
@@ skipping 34 matching lines @@
     return true;
 
   GetCleanedString(dict, kFullNameField, contact->mutable_full_name());
   GetCleanedString(dict, kGivenNameField, contact->mutable_given_name());
   GetCleanedString(
       dict, kAdditionalNameField, contact->mutable_additional_name());
   GetCleanedString(dict, kFamilyNameField, contact->mutable_family_name());
   GetCleanedString(dict, kNamePrefixField, contact->mutable_name_prefix());
   GetCleanedString(dict, kNameSuffixField, contact->mutable_name_suffix());
 
-  const ListValue* email_list = NULL;
+  const base::ListValue* email_list = NULL;
   if (dict.GetList(kEmailField, &email_list)) {
     for (size_t i = 0; i < email_list->GetSize(); ++i) {
-      const DictionaryValue* email_dict = NULL;
+      const base::DictionaryValue* email_dict = NULL;
       if (!email_list->GetDictionary(i, &email_dict))
         return false;
 
       contacts::Contact_EmailAddress* email = contact->add_email_addresses();
       if (!GetCleanedString(*email_dict,
                             kEmailAddressField,
                             email->mutable_address())) {
         return false;
       }
       email->set_primary(IsAddressPrimary(*email_dict));
       InitAddressType(*email_dict, email->mutable_type());
     }
   }
 
-  const ListValue* phone_list = NULL;
+  const base::ListValue* phone_list = NULL;
   if (dict.GetList(kPhoneField, &phone_list)) {
     for (size_t i = 0; i < phone_list->GetSize(); ++i) {
-      const DictionaryValue* phone_dict = NULL;
+      const base::DictionaryValue* phone_dict = NULL;
       if (!phone_list->GetDictionary(i, &phone_dict))
         return false;
 
       contacts::Contact_PhoneNumber* phone = contact->add_phone_numbers();
       if (!GetCleanedString(*phone_dict,
                             kPhoneNumberField,
                             phone->mutable_number())) {
         return false;
       }
       phone->set_primary(IsAddressPrimary(*phone_dict));
       InitAddressType(*phone_dict, phone->mutable_type());
     }
   }
 
-  const ListValue* address_list = NULL;
+  const base::ListValue* address_list = NULL;
   if (dict.GetList(kPostalAddressField, &address_list)) {
     for (size_t i = 0; i < address_list->GetSize(); ++i) {
-      const DictionaryValue* address_dict = NULL;
+      const base::DictionaryValue* address_dict = NULL;
       if (!address_list->GetDictionary(i, &address_dict))
         return false;
 
       contacts::Contact_PostalAddress* address =
           contact->add_postal_addresses();
       if (!GetCleanedString(*address_dict,
                             kPostalAddressFormattedField,
                             address->mutable_address())) {
         return false;
       }
       address->set_primary(IsAddressPrimary(*address_dict));
       InitAddressType(*address_dict, address->mutable_type());
     }
   }
 
-  const ListValue* im_list = NULL;
+  const base::ListValue* im_list = NULL;
   if (dict.GetList(kInstantMessagingField, &im_list)) {
     for (size_t i = 0; i < im_list->GetSize(); ++i) {
-      const DictionaryValue* im_dict = NULL;
+      const base::DictionaryValue* im_dict = NULL;
       if (!im_list->GetDictionary(i, &im_dict))
         return false;
 
       contacts::Contact_InstantMessagingAddress* im =
           contact->add_instant_messaging_addresses();
       if (!GetCleanedString(*im_dict,
                             kInstantMessagingAddressField,
                             im->mutable_address())) {
         return false;
       }
@@ skipping 259 matching lines @@
     photo_download_timer_.Start(
         FROM_HERE, service_->photo_download_timer_interval_,
         this, &DownloadContactsRequest::StartPhotoDownloads);
     CheckCompletion();
   }
 
   // Processes the raw contacts feed from |feed_data| and fills |contacts_|.
   // Returns true on success.
   bool ProcessContactsFeedData(const base::Value& feed_data) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    const DictionaryValue* toplevel_dict = NULL;
+    const base::DictionaryValue* toplevel_dict = NULL;
     if (!feed_data.GetAsDictionary(&toplevel_dict)) {
       LOG(WARNING) << "Top-level object is not a dictionary";
       return false;
     }
 
-    const DictionaryValue* feed_dict = NULL;
+    const base::DictionaryValue* feed_dict = NULL;
     if (!toplevel_dict->GetDictionary(kFeedField, &feed_dict)) {
       LOG(WARNING) << "Feed dictionary missing";
       return false;
     }
 
     // Check the category field to confirm that this is actually a contact feed.
-    const ListValue* category_list = NULL;
+    const base::ListValue* category_list = NULL;
     if (!feed_dict->GetList(kCategoryField, &category_list)) {
       LOG(WARNING) << "Category list missing";
       return false;
     }
-    const DictionaryValue* category_dict = NULL;
+    const base::DictionaryValue* category_dict = NULL;
     if (category_list->GetSize() != 1 ||
         !category_list->GetDictionary(0, &category_dict)) {
       LOG(WARNING) << "Unable to get dictionary from category list of size "
                    << category_list->GetSize();
       return false;
     }
     std::string category_scheme, category_term;
     if (!category_dict->GetString(kCategorySchemeField, &category_scheme) ||
         !category_dict->GetString(kCategoryTermField, &category_term) ||
         category_scheme != kCategorySchemeValue ||
         category_term != kCategoryTermValue) {
       LOG(WARNING) << "Unexpected category (scheme was \"" << category_scheme
                    << "\", term was \"" << category_term << "\")";
       return false;
     }
 
     // A missing entry list means no entries (maybe we're doing an incremental
     // update and nothing has changed).
-    const ListValue* entry_list = NULL;
+    const base::ListValue* entry_list = NULL;
     if (!feed_dict->GetList(kEntryField, &entry_list))
       return true;
 
     contacts_needing_photo_downloads_.reserve(entry_list->GetSize());
 
-    for (ListValue::const_iterator entry_it = entry_list->begin();
+    for (base::ListValue::const_iterator entry_it = entry_list->begin();
          entry_it != entry_list->end(); ++entry_it) {
       const size_t index = (entry_it - entry_list->begin());
-      const DictionaryValue* contact_dict = NULL;
+      const base::DictionaryValue* contact_dict = NULL;
       if (!(*entry_it)->GetAsDictionary(&contact_dict)) {
         LOG(WARNING) << "Entry " << index << " isn't a dictionary";
         return false;
       }
 
       scoped_ptr<contacts::Contact> contact(new contacts::Contact);
       if (!FillContactFromDictionary(*contact_dict, contact.get())) {
         LOG(WARNING) << "Unable to fill entry " << index;
         return false;
       }
@@ skipping 201 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(request);
   VLOG(1) << "Download request " << request << " complete";
   if (!request->my_contacts_group_id().empty())
     cached_my_contacts_group_id_ = request->my_contacts_group_id();
   requests_.erase(request);
   delete request;
 }
 
 }  // namespace contacts