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

chrome/browser/custom_handlers/protocol_handler_registry.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/custom_handlers/protocol_handler_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 426 matching lines @@
   is_loading_ = true;
 
   PrefService* prefs = profile_->GetPrefs();
   if (prefs->HasPrefPath(prefs::kCustomHandlersEnabled)) {
     if (prefs->GetBoolean(prefs::kCustomHandlersEnabled)) {
       Enable();
     } else {
       Disable();
     }
   }
-  std::vector<const DictionaryValue*> registered_handlers =
+  std::vector<const base::DictionaryValue*> registered_handlers =
       GetHandlersFromPref(prefs::kRegisteredProtocolHandlers);
-  for (std::vector<const DictionaryValue*>::const_iterator p =
+  for (std::vector<const base::DictionaryValue*>::const_iterator p =
        registered_handlers.begin();
        p != registered_handlers.end(); ++p) {
     ProtocolHandler handler = ProtocolHandler::CreateProtocolHandler(*p);
     RegisterProtocolHandler(handler);
     bool is_default = false;
     if ((*p)->GetBoolean("default", &is_default) && is_default) {
       SetDefault(handler);
     }
   }
-  std::vector<const DictionaryValue*> ignored_handlers =
+  std::vector<const base::DictionaryValue*> ignored_handlers =
     GetHandlersFromPref(prefs::kIgnoredProtocolHandlers);
-  for (std::vector<const DictionaryValue*>::const_iterator p =
+  for (std::vector<const base::DictionaryValue*>::const_iterator p =
        ignored_handlers.begin();
        p != ignored_handlers.end(); ++p) {
     IgnoreProtocolHandler(ProtocolHandler::CreateProtocolHandler(*p));
   }
   is_loading_ = false;
 
   // For each default protocol handler, check that we are still registered
   // with the OS as the default application.
   if (ShouldRemoveHandlersNotInOS()) {
     for (ProtocolHandlerMap::const_iterator p = default_handlers_.begin();
@@ skipping 260 matching lines @@
   ProtocolHandlerList& list = p->second;
   list.erase(std::find(list.begin(), list.end(), handler));
   list.insert(list.begin(), handler);
 }
 
 void ProtocolHandlerRegistry::Save() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (is_loading_) {
     return;
   }
-  scoped_ptr<Value> registered_protocol_handlers(EncodeRegisteredHandlers());
-  scoped_ptr<Value> ignored_protocol_handlers(EncodeIgnoredHandlers());
-  scoped_ptr<Value> enabled(Value::CreateBooleanValue(enabled_));
+  scoped_ptr<base::Value> registered_protocol_handlers(
+      EncodeRegisteredHandlers());
+  scoped_ptr<base::Value> ignored_protocol_handlers(EncodeIgnoredHandlers());
+  scoped_ptr<base::Value> enabled(base::Value::CreateBooleanValue(enabled_));
   profile_->GetPrefs()->Set(prefs::kRegisteredProtocolHandlers,
       *registered_protocol_handlers);
   profile_->GetPrefs()->Set(prefs::kIgnoredProtocolHandlers,
       *ignored_protocol_handlers);
   profile_->GetPrefs()->Set(prefs::kCustomHandlersEnabled, *enabled);
 }
 
 const ProtocolHandlerRegistry::ProtocolHandlerList*
 ProtocolHandlerRegistry::GetHandlerList(
     const std::string& scheme) const {
@@ skipping 30 matching lines @@
   if (p != protocol_handlers_.end()) {
     p->second.push_back(handler);
     return;
   }
 
   ProtocolHandlerList new_list;
   new_list.push_back(handler);
   protocol_handlers_[handler.protocol()] = new_list;
 }
 
-Value* ProtocolHandlerRegistry::EncodeRegisteredHandlers() {
+base::Value* ProtocolHandlerRegistry::EncodeRegisteredHandlers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ListValue* protocol_handlers = new ListValue();
+  base::ListValue* protocol_handlers = new base::ListValue();
   for (ProtocolHandlerMultiMap::iterator i = protocol_handlers_.begin();
        i != protocol_handlers_.end(); ++i) {
     for (ProtocolHandlerList::iterator j = i->second.begin();
          j != i->second.end(); ++j) {
-      DictionaryValue* encoded = j->Encode();
+      base::DictionaryValue* encoded = j->Encode();
       if (IsDefault(*j)) {
-        encoded->Set("default", Value::CreateBooleanValue(true));
+        encoded->Set("default", base::Value::CreateBooleanValue(true));
       }
       protocol_handlers->Append(encoded);
     }
   }
   return protocol_handlers;
 }
 
-Value* ProtocolHandlerRegistry::EncodeIgnoredHandlers() {
+base::Value* ProtocolHandlerRegistry::EncodeIgnoredHandlers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ListValue* handlers = new ListValue();
+  base::ListValue* handlers = new base::ListValue();
   for (ProtocolHandlerList::iterator i = ignored_protocol_handlers_.begin();
        i != ignored_protocol_handlers_.end(); ++i) {
     handlers->Append(i->Encode());
   }
   return handlers;
 }
 
 void ProtocolHandlerRegistry::NotifyChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }
 
 void ProtocolHandlerRegistry::RegisterProtocolHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(CanSchemeBeOverridden(handler.protocol()));
   DCHECK(!handler.IsEmpty());
   if (IsRegistered(handler)) {
     return;
   }
   if (enabled_ && !delegate_->IsExternalHandlerRegistered(handler.protocol()))
     delegate_->RegisterExternalHandler(handler.protocol());
   InsertHandler(handler);
 }
 
-std::vector<const DictionaryValue*>
+std::vector<const base::DictionaryValue*>
 ProtocolHandlerRegistry::GetHandlersFromPref(const char* pref_name) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::vector<const DictionaryValue*> result;
+  std::vector<const base::DictionaryValue*> result;
   PrefService* prefs = profile_->GetPrefs();
   if (!prefs->HasPrefPath(pref_name)) {
     return result;
   }
 
-  const ListValue* handlers = prefs->GetList(pref_name);
+  const base::ListValue* handlers = prefs->GetList(pref_name);
   if (handlers) {
     for (size_t i = 0; i < handlers->GetSize(); ++i) {
-      const DictionaryValue* dict;
+      const base::DictionaryValue* dict;
       if (!handlers->GetDictionary(i, &dict))
         continue;
       if (ProtocolHandler::IsValidDict(dict)) {
         result.push_back(dict);
       }
     }
   }
   return result;
 }
 
@@ skipping 12 matching lines @@
 
 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // this is always created on the UI thread (in profile_io's
   // InitializeOnUIThread. Any method calls must be done
   // on the IO thread (this is checked).
   return scoped_ptr<JobInterceptorFactory>(
       new JobInterceptorFactory(io_thread_delegate_.get()));
 }