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

chrome/browser/content_settings/content_settings_default_provider.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/content_settings/content_settings_default_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 81 matching lines @@
 
 // static
 void DefaultProvider::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // The registration of the preference prefs::kDefaultContentSettings should
   // also include the default values for default content settings. This allows
   // functional tests to get default content settings by reading the preference
   // prefs::kDefaultContentSettings via pyauto.
   // TODO(markusheintz): Write pyauto hooks for the content settings map as
   // content settings should be read from the host content settings map.
-  DictionaryValue* default_content_settings = new DictionaryValue();
+  base::DictionaryValue* default_content_settings = new base::DictionaryValue();
   registry->RegisterDictionaryPref(
       prefs::kDefaultContentSettings,
       default_content_settings,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
 DefaultProvider::DefaultProvider(PrefService* prefs, bool incognito)
     : prefs_(prefs),
       is_incognito_(incognito),
       updating_preferences_(false) {
@@ skipping 60 matching lines @@
 }
 
 DefaultProvider::~DefaultProvider() {
 }
 
 bool DefaultProvider::SetWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
-    Value* in_value) {
+    base::Value* in_value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs_);
 
   // Ignore non default settings
   if (primary_pattern != ContentSettingsPattern::Wildcard() ||
       secondary_pattern != ContentSettingsPattern::Wildcard()) {
     return false;
   }
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
   if (is_incognito_)
     return false;
 
   // Put |in_value| in a scoped pointer to ensure that it gets cleaned up
   // properly if we don't pass on the ownership.
   scoped_ptr<base::Value> value(in_value);
   {
     base::AutoReset<bool> auto_reset(&updating_preferences_, true);
 
     // |DefaultProvider| should not send any notifications when holding
     // |lock_|. |DictionaryPrefUpdate| destructor and
     // |PrefService::SetInteger()| send out notifications. As a response, the
     // upper layers may call |GetAllContentSettingRules| which acquires |lock_|
     // again.
     DictionaryPrefUpdate update(prefs_, prefs::kDefaultContentSettings);
-    DictionaryValue* default_settings_dictionary = update.Get();
+    base::DictionaryValue* default_settings_dictionary = update.Get();
     base::AutoLock lock(lock_);
     if (value.get() == NULL ||
         ValueToContentSetting(value.get()) == kDefaultSettings[content_type]) {
       // If |value| is NULL we need to reset the default setting the the
       // hardcoded default.
       default_settings_[content_type].reset(
-          Value::CreateIntegerValue(kDefaultSettings[content_type]));
+          base::Value::CreateIntegerValue(kDefaultSettings[content_type]));
 
       // Remove the corresponding pref entry since the hardcoded default value
       // is used.
       default_settings_dictionary->RemoveWithoutPathExpansion(
           GetTypeName(content_type), NULL);
     } else {
       default_settings_[content_type].reset(value->DeepCopy());
       // Transfer ownership of |value| to the |default_settings_dictionary|.
       default_settings_dictionary->SetWithoutPathExpansion(
           GetTypeName(content_type), value.release());
@@ skipping 52 matching lines @@
   }
 
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   CONTENT_SETTINGS_TYPE_DEFAULT,
                   std::string());
 }
 
 void DefaultProvider::ReadDefaultSettings(bool overwrite) {
   base::AutoLock lock(lock_);
-  const DictionaryValue* default_settings_dictionary =
+  const base::DictionaryValue* default_settings_dictionary =
       prefs_->GetDictionary(prefs::kDefaultContentSettings);
 
   if (overwrite)
     default_settings_.clear();
 
   // Careful: The returned value could be NULL if the pref has never been set.
   if (default_settings_dictionary)
     GetSettingsFromDictionary(default_settings_dictionary);
 
   ForceDefaultsToBeExplicit();
 }
 
 void DefaultProvider::ForceDefaultsToBeExplicit() {
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
     ContentSettingsType type = ContentSettingsType(i);
     if (!default_settings_[type].get() &&
         kDefaultSettings[i] != CONTENT_SETTING_DEFAULT) {
       default_settings_[type].reset(
-          Value::CreateIntegerValue(kDefaultSettings[i]));
+          base::Value::CreateIntegerValue(kDefaultSettings[i]));
     }
   }
 }
 
 void DefaultProvider::GetSettingsFromDictionary(
-    const DictionaryValue* dictionary) {
-  for (DictionaryValue::Iterator i(*dictionary); !i.IsAtEnd(); i.Advance()) {
+    const base::DictionaryValue* dictionary) {
+  for (base::DictionaryValue::Iterator i(*dictionary);
+       !i.IsAtEnd(); i.Advance()) {
     const std::string& content_type(i.key());
     for (size_t type = 0; type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
       if (content_type == GetTypeName(ContentSettingsType(type))) {
         int int_value = CONTENT_SETTING_DEFAULT;
         bool is_integer = i.value().GetAsInteger(&int_value);
         DCHECK(is_integer);
         default_settings_[ContentSettingsType(type)].reset(
-            Value::CreateIntegerValue(int_value));
+            base::Value::CreateIntegerValue(int_value));
         break;
       }
     }
   }
   // Migrate obsolete cookie prompt mode.
   if (ValueToContentSetting(
           default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].get()) ==
               CONTENT_SETTING_ASK) {
     default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].reset(
-        Value::CreateIntegerValue(CONTENT_SETTING_BLOCK));
+        base::Value::CreateIntegerValue(CONTENT_SETTING_BLOCK));
   }
 }
 
 }  // namespace content_settings