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

chrome/browser/background/background_contents_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/background/background_contents_service.h"
 
 #include "apps/app_load_service.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 480 matching lines @@
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&ReloadExtension, extension->id(), profile),
       base::TimeDelta::FromMilliseconds(restart_delay_in_ms_));
 }
 
 // Loads all background contents whose urls have been stored in prefs.
 void BackgroundContentsService::LoadBackgroundContentsFromPrefs(
     Profile* profile) {
   if (!prefs_)
     return;
-  const DictionaryValue* contents =
+  const base::DictionaryValue* contents =
       prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
   if (!contents)
     return;
   ExtensionService* extensions_service =
           extensions::ExtensionSystem::Get(profile)->extension_service();
   DCHECK(extensions_service);
-  for (DictionaryValue::Iterator it(*contents); !it.IsAtEnd(); it.Advance()) {
+  for (base::DictionaryValue::Iterator it(*contents);
+       !it.IsAtEnd(); it.Advance()) {
     // Check to make sure that the parent extension is still enabled.
     const Extension* extension = extensions_service->
         GetExtensionById(it.key(), false);
     if (!extension) {
       // We should never reach here - it should not be possible for an app
       // to become uninstalled without the associated BackgroundContents being
       // unregistered via the EXTENSIONS_UNLOADED notification, unless there's a
       // crash before we could save our prefs, or if the user deletes the
       // extension files manually rather than uninstalling it.
       NOTREACHED() << "No extension found for BackgroundContents - id = "
@@ skipping 25 matching lines @@
     LoadBackgroundContents(profile,
                            BackgroundInfo::GetBackgroundURL(extension),
                            ASCIIToUTF16("background"),
                            UTF8ToUTF16(extension->id()));
     return;
   }
 
   // Now look in the prefs.
   if (!prefs_)
     return;
-  const DictionaryValue* contents =
+  const base::DictionaryValue* contents =
       prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
   if (!contents)
     return;
   LoadBackgroundContentsFromDictionary(profile, extension_id, contents);
 }
 
 void BackgroundContentsService::LoadBackgroundContentsFromDictionary(
     Profile* profile,
     const std::string& extension_id,
-    const DictionaryValue* contents) {
+    const base::DictionaryValue* contents) {
   ExtensionService* extensions_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   DCHECK(extensions_service);
 
-  const DictionaryValue* dict;
+  const base::DictionaryValue* dict;
   if (!contents->GetDictionaryWithoutPathExpansion(extension_id, &dict) ||
       dict == NULL)
     return;
 
   base::string16 frame_name;
   std::string url;
   dict->GetString(kUrlKey, &url);
   dict->GetString(kFrameNameKey, &frame_name);
   LoadBackgroundContents(profile,
                          GURL(url),
@@ skipping 78 matching lines @@
     BackgroundContents* background_contents) {
   DCHECK(IsTracked(background_contents));
   if (!prefs_)
     return;
 
   // We store the first URL we receive for a given application. If there's
   // already an entry for this application, no need to do anything.
   // TODO(atwilson): Verify that this is the desired behavior based on developer
   // feedback (http://crbug.com/47118).
   DictionaryPrefUpdate update(prefs_, prefs::kRegisteredBackgroundContents);
-  DictionaryValue* pref = update.Get();
+  base::DictionaryValue* pref = update.Get();
   const base::string16& appid = GetParentApplicationId(background_contents);
-  DictionaryValue* current;
+  base::DictionaryValue* current;
   if (pref->GetDictionaryWithoutPathExpansion(UTF16ToUTF8(appid), &current))
     return;
 
   // No entry for this application yet, so add one.
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString(kUrlKey, background_contents->GetURL().spec());
   dict->SetString(kFrameNameKey, contents_map_[appid].frame_name);
   pref->SetWithoutPathExpansion(UTF16ToUTF8(appid), dict);
 }
 
 bool BackgroundContentsService::HasRegisteredBackgroundContents(
     const base::string16& app_id) {
   if (!prefs_)
     return false;
   std::string app = UTF16ToUTF8(app_id);
-  const DictionaryValue* contents =
+  const base::DictionaryValue* contents =
       prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
   return contents->HasKey(app);
 }
 
 void BackgroundContentsService::UnregisterBackgroundContents(
     BackgroundContents* background_contents) {
   if (!prefs_)
     return;
   DCHECK(IsTracked(background_contents));
   const base::string16 appid = GetParentApplicationId(background_contents);
@@ skipping 60 matching lines @@
     bool user_gesture,
     bool* was_blocked) {
   Browser* browser = chrome::FindLastActiveWithProfile(
       Profile::FromBrowserContext(new_contents->GetBrowserContext()),
       chrome::GetActiveDesktop());
   if (browser) {
     chrome::AddWebContents(browser, NULL, new_contents, disposition,
                            initial_pos, user_gesture, was_blocked);
   }
 }