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

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 167 matching lines @@
       profile->GetPrefs()->GetDictionary(kExtensionURLOverrides);
   std::string page = url->host();
   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;
+    const base::Value* val = NULL;
     url_list->Get(i, &val);
 
     // Verify that the override value is good.  If not, unregister it and find
     // the next one.
     std::string override;
     if (!val->GetAsString(&override)) {
       NOTREACHED();
       UnregisterChromeURLOverride(page, profile, val);
       continue;
     }
@@ skipping 105 matching lines @@
         }
         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()));
+    page_overrides->Insert(0, new base::StringValue(iter->second.spec()));
   }
 }
 
 // static
 void ExtensionWebUI::UnregisterAndReplaceOverride(const std::string& page,
                                                   Profile* profile,
                                                   base::ListValue* list,
-                                                  const Value* override) {
+                                                  const base::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);
     extensions::ExtensionTabUtil::ForEachTab(callback);
   }
 }
 
 // static
 void ExtensionWebUI::UnregisterChromeURLOverride(const std::string& page,
                                                  Profile* profile,
-                                                 const Value* override) {
+                                                 const base::Value* override) {
   if (!override)
     return;
   PrefService* prefs = profile->GetPrefs();
   DictionaryPrefUpdate update(prefs, kExtensionURLOverrides);
   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;
@@ skipping 12 matching lines @@
   base::DictionaryValue* all_overrides = update.Get();
   URLOverrides::URLOverrideMap::const_iterator iter = overrides.begin();
   for (; iter != overrides.end(); ++iter) {
     const std::string& page = iter->first;
     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());
+      base::StringValue override(iter->second.spec());
       UnregisterAndReplaceOverride(iter->first, profile,
                                    page_overrides, &override);
     }
   }
 }
 
 // static
 void ExtensionWebUI::GetFaviconForURL(
     Profile* profile,
     const GURL& page_url,
@@ skipping 32 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));
 }