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

chrome/browser/extensions/menu_manager.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/menu_manager.h"
 
 #include <algorithm>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 72 matching lines @@
       continue;
     items.push_back(item);
   }
   return items;
 }
 
 scoped_ptr<base::Value> MenuItemsToValue(const MenuItem::List& items) {
   scoped_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < items.size(); ++i)
     list->Append(items[i]->ToValue().release());
-  return scoped_ptr<Value>(list.release());
+  return scoped_ptr<base::Value>(list.release());
 }
 
-bool GetStringList(const DictionaryValue& dict,
+bool GetStringList(const base::DictionaryValue& dict,
                    const std::string& key,
                    std::vector<std::string>* out) {
   if (!dict.HasKey(key))
     return true;
 
   const base::ListValue* list = NULL;
   if (!dict.GetListWithoutPathExpansion(key, &list))
     return false;
 
   for (size_t i = 0; i < list->GetSize(); ++i) {
@@ skipping 77 matching lines @@
     return false;
   checked_ = checked;
   return true;
 }
 
 void MenuItem::AddChild(MenuItem* item) {
   item->parent_id_.reset(new Id(id_));
   children_.push_back(item);
 }
 
-scoped_ptr<DictionaryValue> MenuItem::ToValue() const {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue);
+scoped_ptr<base::DictionaryValue> MenuItem::ToValue() const {
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   // Should only be called for extensions with event pages, which only have
   // string IDs for items.
   DCHECK_EQ(0, id_.uid);
   value->SetString(kStringUIDKey, id_.string_uid);
   value->SetBoolean(kIncognitoKey, id_.incognito);
   value->SetInteger(kTypeKey, type_);
   if (type_ != SEPARATOR)
     value->SetString(kTitleKey, title_);
   if (type_ == CHECKBOX || type_ == RADIO)
     value->SetBoolean(kCheckedKey, checked_);
   value->SetBoolean(kEnabledKey, enabled_);
   value->Set(kContextsKey, contexts_.ToValue().release());
   if (parent_id_) {
     DCHECK_EQ(0, parent_id_->uid);
     value->SetString(kParentUIDKey, parent_id_->string_uid);
   }
   value->Set(kDocumentURLPatternsKey,
              document_url_patterns_.ToValue().release());
   value->Set(kTargetURLPatternsKey, target_url_patterns_.ToValue().release());
   return value.Pass();
 }
 
 // static
 MenuItem* MenuItem::Populate(const std::string& extension_id,
-                             const DictionaryValue& value,
+                             const base::DictionaryValue& value,
                              std::string* error) {
   bool incognito = false;
   if (!value.GetBoolean(kIncognitoKey, &incognito))
     return NULL;
   Id id(incognito, extension_id);
   if (!value.GetString(kStringUIDKey, &id.string_uid))
     return NULL;
   int type_int;
   Type type = NORMAL;
   if (!value.GetInteger(kTypeKey, &type_int))
     return NULL;
   type = static_cast<Type>(type_int);
   std::string title;
   if (type != SEPARATOR && !value.GetString(kTitleKey, &title))
     return NULL;
   bool checked = false;
   if ((type == CHECKBOX || type == RADIO) &&
       !value.GetBoolean(kCheckedKey, &checked)) {
     return NULL;
   }
   bool enabled = true;
   if (!value.GetBoolean(kEnabledKey, &enabled))
     return NULL;
   ContextList contexts;
-  const Value* contexts_value = NULL;
+  const base::Value* contexts_value = NULL;
   if (!value.Get(kContextsKey, &contexts_value))
     return NULL;
   if (!contexts.Populate(*contexts_value))
     return NULL;
 
   scoped_ptr<MenuItem> result(new MenuItem(
       id, title, checked, enabled, type, contexts));
 
   std::vector<std::string> document_url_patterns;
   if (!GetStringList(value, kDocumentURLPatternsKey, &document_url_patterns))
@@ skipping 325 matching lines @@
   }
 
   // Now iterate forwards from |item| and uncheck any adjacent radio items.
   for (i = item_location + 1; i != list->end(); ++i) {
     if ((*i)->type() != MenuItem::RADIO)
       break;
     (*i)->SetChecked(false);
   }
 }
 
-static void AddURLProperty(DictionaryValue* dictionary,
+static void AddURLProperty(base::DictionaryValue* dictionary,
                            const std::string& key, const GURL& url) {
   if (!url.is_empty())
     dictionary->SetString(key, url.possibly_invalid_spec());
 }
 
 void MenuManager::ExecuteCommand(Profile* profile,
                                  WebContents* web_contents,
                                  const content::ContextMenuParams& params,
                                  const MenuItem::Id& menu_item_id) {
   EventRouter* event_router = extensions::ExtensionSystem::Get(profile)->
       event_router();
   if (!event_router)
     return;
 
   MenuItem* item = GetItemById(menu_item_id);
   if (!item)
     return;
 
   // ExtensionService/Extension can be NULL in unit tests :(
   ExtensionService* service =
       ExtensionSystem::Get(profile_)->extension_service();
   const Extension* extension = service ?
       service->extensions()->GetByID(menu_item_id.extension_id) : NULL;
 
   if (item->type() == MenuItem::RADIO)
     RadioItemSelected(item);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
 
-  DictionaryValue* properties = new DictionaryValue();
+  base::DictionaryValue* properties = new base::DictionaryValue();
   SetIdKeyValue(properties, "menuItemId", item->id());
   if (item->parent_id())
     SetIdKeyValue(properties, "parentMenuItemId", *item->parent_id());
 
   switch (params.media_type) {
     case blink::WebContextMenuData::MediaTypeImage:
       properties->SetString("mediaType", "image");
       break;
     case blink::WebContextMenuData::MediaTypeVideo:
       properties->SetString("mediaType", "video");
@@ skipping 16 matching lines @@
 
   args->Append(properties);
 
   // Add the tab info to the argument list.
   // No tab info in a platform app.
   if (!extension || !extension->is_platform_app()) {
     // Note: web_contents are NULL in unit tests :(
     if (web_contents) {
       args->Append(ExtensionTabUtil::CreateTabValue(web_contents));
     } else {
-      args->Append(new DictionaryValue());
+      args->Append(new base::DictionaryValue());
     }
   }
 
   if (item->type() == MenuItem::CHECKBOX ||
       item->type() == MenuItem::RADIO) {
     bool was_checked = item->checked();
     properties->SetBoolean("wasChecked", was_checked);
 
     // RADIO items always get set to true when you click on them, but CHECKBOX
     // items get their state toggled.
@@ skipping 219 matching lines @@
       if (uid < other.uid)
         return true;
       if (uid == other.uid)
         return string_uid < other.string_uid;
     }
   }
   return false;
 }
 
 }  // namespace extensions