Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.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/api/bookmark_manager_private/bookmark_manager_private_api.h"
 
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "base/prefs/pref_service.h"
@@ skipping 70 matching lines @@
       return false;
     nodes->push_back(node);
   }
 
   return true;
 }
 
 // Recursively adds a node to a list. This is by used |BookmarkNodeDataToJSON|
 // when the data comes from the current profile. In this case we have a
 // BookmarkNode since we got the data from the current profile.
-void AddNodeToList(ListValue* list, const BookmarkNode& node) {
-  DictionaryValue* dict = new DictionaryValue();
+void AddNodeToList(base::ListValue* list, const BookmarkNode& node) {
+  base::DictionaryValue* dict = new base::DictionaryValue();
 
   // Add id and parentId so we can associate the data with existing nodes on the
   // client side.
   std::string id_string = base::Int64ToString(node.id());
   dict->SetString(bookmark_keys::kIdKey, id_string);
 
   std::string parent_id_string = base::Int64ToString(node.parent()->id());
   dict->SetString(bookmark_keys::kParentIdKey, parent_id_string);
 
   if (node.is_url())
     dict->SetString(bookmark_keys::kUrlKey, node.url().spec());
 
   dict->SetString(bookmark_keys::kTitleKey, node.GetTitle());
 
-  ListValue* children = new ListValue();
+  base::ListValue* children = new base::ListValue();
   for (int i = 0; i < node.child_count(); ++i)
     AddNodeToList(children, *node.GetChild(i));
   dict->Set(bookmark_keys::kChildrenKey, children);
 
   list->Append(dict);
 }
 
 // Recursively adds an element to a list. This is used by
 // |BookmarkNodeDataToJSON| when the data comes from a different profile. When
 // the data comes from a different profile we do not have any IDs or parent IDs.
-void AddElementToList(ListValue* list,
+void AddElementToList(base::ListValue* list,
                       const BookmarkNodeData::Element& element) {
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
 
   if (element.is_url)
     dict->SetString(bookmark_keys::kUrlKey, element.url.spec());
 
   dict->SetString(bookmark_keys::kTitleKey, element.title);
 
-  ListValue* children = new ListValue();
+  base::ListValue* children = new base::ListValue();
   for (size_t i = 0; i < element.children.size(); ++i)
     AddElementToList(children, element.children[i]);
   dict->Set(bookmark_keys::kChildrenKey, children);
 
   list->Append(dict);
 }
 
 // Builds the JSON structure based on the BookmarksDragData.
 void BookmarkNodeDataToJSON(Profile* profile, const BookmarkNodeData& data,
-                            ListValue* args) {
+                            base::ListValue* args) {
   bool same_profile = data.IsFromProfile(profile);
-  DictionaryValue* value = new DictionaryValue();
+  base::DictionaryValue* value = new base::DictionaryValue();
   value->SetBoolean(manager_keys::kSameProfileKey, same_profile);
 
-  ListValue* list = new ListValue();
+  base::ListValue* list = new base::ListValue();
   if (same_profile) {
     std::vector<const BookmarkNode*> nodes = data.GetNodes(profile);
     for (size_t i = 0; i < nodes.size(); ++i)
       AddNodeToList(list, *nodes[i]);
   } else {
     // We do not have an node IDs when the data comes from a different profile.
     std::vector<BookmarkNodeData::Element> elements = data.elements;
     for (size_t i = 0; i < elements.size(); ++i)
       AddElementToList(list, elements[i]);
   }
@@ skipping 16 matching lines @@
 
 BookmarkManagerPrivateEventRouter::~BookmarkManagerPrivateEventRouter() {
   BookmarkTabHelper* bookmark_tab_helper =
       BookmarkTabHelper::FromWebContents(web_contents_);
   if (bookmark_tab_helper->bookmark_drag_delegate() == this)
     bookmark_tab_helper->set_bookmark_drag_delegate(NULL);
 }
 
 void BookmarkManagerPrivateEventRouter::DispatchEvent(
     const char* event_name,
-    scoped_ptr<ListValue> args) {
+    scoped_ptr<base::ListValue> args) {
   if (!ExtensionSystem::Get(profile_)->event_router())
     return;
 
   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
   ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
 }
 
 void BookmarkManagerPrivateEventRouter::DispatchDragEvent(
     const BookmarkNodeData& data,
     const char* event_name) {
   if (data.size() == 0)
     return;
 
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   BookmarkNodeDataToJSON(profile_, data, args.get());
   DispatchEvent(event_name, args.Pass());
 }
 
 void BookmarkManagerPrivateEventRouter::OnDragEnter(
     const BookmarkNodeData& data) {
   DispatchDragEvent(data, manager_keys::kOnBookmarkDragEnter);
 }
 
 void BookmarkManagerPrivateEventRouter::OnDragOver(
@@ skipping 112 matching lines @@
   const BookmarkNode* parent_node = GetNodeFromString(model, params->parent_id);
   if (!parent_node) {
     error_ = bookmark_keys::kNoParentError;
     return false;
   }
   model->SortChildren(parent_node);
   return true;
 }
 
 bool BookmarkManagerPrivateGetStringsFunction::RunImpl() {
-  DictionaryValue* localized_strings = new DictionaryValue();
+  base::DictionaryValue* localized_strings = new base::DictionaryValue();
 
   localized_strings->SetString("title",
       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_TITLE));
   localized_strings->SetString("search_button",
       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_SEARCH_BUTTON));
   localized_strings->SetString("organize_menu",
       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_ORGANIZE_MENU));
   localized_strings->SetString("show_in_folder",
       l10n_util::GetStringUTF16(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
   localized_strings->SetString("sort",
@@ skipping 157 matching lines @@
       return false;
     }
     node = model->GetNodeByID(id);
   }
 
   if (!node) {
     error_ = bookmark_keys::kNoNodeError;
     return false;
   }
 
-  scoped_ptr<ListValue> json(new ListValue());
+  scoped_ptr<base::ListValue> json(new base::ListValue());
   if (params->folders_only)
     bookmark_api_helpers::AddNodeFoldersOnly(node, json.get(), true);
   else
     bookmark_api_helpers::AddNode(node, json.get(), true);
   SetResult(json.release());
   return true;
 }
 
 bool BookmarkManagerPrivateCanEditFunction::RunImpl() {
   PrefService* prefs = user_prefs::UserPrefs::Get(profile_);
@@ skipping 13 matching lines @@
 #if defined(OS_WIN)
   if (win8::IsSingleWindowMetroMode())
     can_open_new_windows = false;
 #endif  // OS_WIN
 
   SetResult(new base::FundamentalValue(can_open_new_windows));
   return true;
 }
 
 }  // namespace extensions