Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/extension_web_ui.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/extensions/extension_web_ui.h"
 
 #include <set>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 27 matching lines @@
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::WebContents;
 using extensions::Extension;
 using extensions::URLOverrides;
 
 namespace {
 
 // De-dupes the items in |list|. Assumes the values are strings.
-void CleanUpDuplicates(ListValue* list) {
+void CleanUpDuplicates(base::ListValue* list) {
   std::set<std::string> seen_values;
 
   // Loop backwards as we may be removing items.
   for (size_t i = list->GetSize() - 1; (i + 1) > 0; --i) {
     std::string value;
     if (!list->GetString(i, &value)) {
       NOTREACHED();
       continue;
     }
 
@@ skipping 112 matching lines @@
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 bool ExtensionWebUI::HandleChromeURLOverride(
     GURL* url, content::BrowserContext* browser_context) {
   if (!url->SchemeIs(chrome::kChromeUIScheme))
     return false;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
-  const DictionaryValue* overrides =
+  const base::DictionaryValue* overrides =
       profile->GetPrefs()->GetDictionary(kExtensionURLOverrides);
   std::string page = url->host();
-  const ListValue* url_list = NULL;
+  const base::ListValue* url_list = NULL;
   if (!overrides || !overrides->GetList(page, &url_list))
     return false;
 
   ExtensionService* service = profile->GetExtensionService();
 
   size_t i = 0;
   while (i < url_list->GetSize()) {
     const Value* val = NULL;
     url_list->Get(i, &val);
 
@@ skipping 42 matching lines @@
     *url = extension_url;
     return true;
   }
   return false;
 }
 
 // static
 bool ExtensionWebUI::HandleChromeURLOverrideReverse(
     GURL* url, content::BrowserContext* browser_context) {
   Profile* profile = Profile::FromBrowserContext(browser_context);
-  const DictionaryValue* overrides =
+  const base::DictionaryValue* overrides =
       profile->GetPrefs()->GetDictionary(kExtensionURLOverrides);
   if (!overrides)
     return false;
 
   // Find the reverse mapping based on the given URL. For example this maps the
   // internal URL
   // chrome-extension://eemcgdkfndhakfknompkggombfjjjeno/main.html#1 to
   // chrome://bookmarks/#1 for display in the omnibox.
-  for (DictionaryValue::Iterator it(*overrides); !it.IsAtEnd(); it.Advance()) {
-    const ListValue* url_list = NULL;
+  for (base::DictionaryValue::Iterator it(*overrides); !it.IsAtEnd();
+       it.Advance()) {
+    const base::ListValue* url_list = NULL;
     if (!it.value().GetAsList(&url_list))
       continue;
 
-    for (ListValue::const_iterator it2 = url_list->begin();
+    for (base::ListValue::const_iterator it2 = url_list->begin();
          it2 != url_list->end(); ++it2) {
       std::string override;
       if (!(*it2)->GetAsString(&override))
         continue;
       if (StartsWithASCII(url->spec(), override, true)) {
         GURL original_url(chrome::kChromeUIScheme + std::string("://") +
                           it.key() + url->spec().substr(override.length()));
         *url = original_url;
         return true;
       }
     }
   }
 
   return false;
 }
 
 // static
 void ExtensionWebUI::RegisterChromeURLOverrides(
     Profile* profile, const URLOverrides::URLOverrideMap& overrides) {
   if (overrides.empty())
     return;
 
   PrefService* prefs = profile->GetPrefs();
   DictionaryPrefUpdate update(prefs, kExtensionURLOverrides);
-  DictionaryValue* all_overrides = update.Get();
+  base::DictionaryValue* all_overrides = update.Get();
 
   // For each override provided by the extension, add it to the front of
   // the override list if it's not already in the list.
   URLOverrides::URLOverrideMap::const_iterator iter = overrides.begin();
   for (; iter != overrides.end(); ++iter) {
     const std::string& key = iter->first;
-    ListValue* page_overrides = NULL;
+    base::ListValue* page_overrides = NULL;
     if (!all_overrides->GetList(key, &page_overrides)) {
-      page_overrides = new ListValue();
+      page_overrides = new base::ListValue();
       all_overrides->Set(key, page_overrides);
     } else {
       CleanUpDuplicates(page_overrides);
 
       // Verify that the override isn't already in the list.
-      ListValue::iterator i = page_overrides->begin();
+      base::ListValue::iterator i = page_overrides->begin();
       for (; i != page_overrides->end(); ++i) {
         std::string override_val;
         if (!(*i)->GetAsString(&override_val)) {
           NOTREACHED();
           continue;
         }
         if (override_val == iter->second.spec())
           break;
       }
       // This value is already in the list, leave it alone.
       if (i != page_overrides->end())
         continue;
     }
     // Insert the override at the front of the list.  Last registered override
     // wins.
     page_overrides->Insert(0, new StringValue(iter->second.spec()));
   }
 }
 
 // static
 void ExtensionWebUI::UnregisterAndReplaceOverride(const std::string& page,
                                                   Profile* profile,
-                                                  ListValue* list,
+                                                  base::ListValue* list,
                                                   const Value* override) {
   size_t index = 0;
   bool found = list->Remove(*override, &index);
   if (found && index == 0) {
     // This is the active override, so we need to find all existing
     // tabs for this override and get them to reload the original URL.
     base::Callback<void(WebContents*)> callback =
         base::Bind(&UnregisterAndReplaceOverrideForWebContents, page, profile);
     ExtensionTabUtil::ForEachTab(callback);
   }
 }
 
 // static
 void ExtensionWebUI::UnregisterChromeURLOverride(const std::string& page,
                                                  Profile* profile,
                                                  const Value* override) {
   if (!override)
     return;
   PrefService* prefs = profile->GetPrefs();
   DictionaryPrefUpdate update(prefs, kExtensionURLOverrides);
-  DictionaryValue* all_overrides = update.Get();
-  ListValue* page_overrides = NULL;
+  base::DictionaryValue* all_overrides = update.Get();
+  base::ListValue* page_overrides = NULL;
   if (!all_overrides->GetList(page, &page_overrides)) {
     // If it's being unregistered, it should already be in the list.
     NOTREACHED();
     return;
   } else {
     UnregisterAndReplaceOverride(page, profile, page_overrides, override);
   }
 }
 
 // static
 void ExtensionWebUI::UnregisterChromeURLOverrides(
     Profile* profile, const URLOverrides::URLOverrideMap& overrides) {
   if (overrides.empty())
     return;
   PrefService* prefs = profile->GetPrefs();
   DictionaryPrefUpdate update(prefs, kExtensionURLOverrides);
-  DictionaryValue* all_overrides = update.Get();
+  base::DictionaryValue* all_overrides = update.Get();
   URLOverrides::URLOverrideMap::const_iterator iter = overrides.begin();
   for (; iter != overrides.end(); ++iter) {
     const std::string& page = iter->first;
-    ListValue* page_overrides = NULL;
+    base::ListValue* page_overrides = NULL;
     if (!all_overrides->GetList(page, &page_overrides)) {
       // If it's being unregistered, it should already be in the list.
       NOTREACHED();
       continue;
     } else {
       StringValue override(iter->second.spec());
       UnregisterAndReplaceOverride(iter->first, profile,
                                    page_overrides, &override);
     }
   }
@@ skipping 38 matching lines @@
             extensions::ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
             gfx::Size(pixel_size, pixel_size),
             scale_factors[i]));
   }
 
   // LoadImagesAsync actually can run callback synchronously. We want to force
   // async.
   extensions::ImageLoader::Get(profile)->LoadImagesAsync(
       extension, info_list, base::Bind(&RunFaviconCallbackAsync, callback));
 }