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

chrome/browser/extensions/api/tabs/tabs_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/tabs/tabs_api.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 310 matching lines @@
 }
 
 bool WindowsGetAllFunction::RunImpl() {
   scoped_ptr<GetAll::Params> params(GetAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
-  ListValue* window_list = new ListValue();
+  base::ListValue* window_list = new base::ListValue();
   const WindowControllerList::ControllerList& windows =
       WindowControllerList::GetInstance()->windows();
   for (WindowControllerList::ControllerList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
     if (!this->CanOperateOnWindow(*iter))
       continue;
     if (populate_tabs)
       window_list->Append((*iter)->CreateWindowValueWithTabs(GetExtension()));
     else
@@ skipping 47 matching lines @@
       error_ = ErrorUtils::FormatErrorMessage(
           keys::kURLsNotAllowedInIncognitoError, first_url_erased);
       *is_error = true;
       return false;
     }
   }
   return incognito;
 }
 
 bool WindowsCreateFunction::RunImpl() {
-  DictionaryValue* args = NULL;
+  base::DictionaryValue* args = NULL;
   std::vector<GURL> urls;
   TabStripModel* source_tab_strip = NULL;
   int tab_index = -1;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   // Look for optional url.
   if (args) {
     if (args->HasKey(keys::kUrlKey)) {
       Value* url_value;
       std::vector<std::string> url_strings;
       args->Get(keys::kUrlKey, &url_value);
 
       // First, get all the URLs the client wants to open.
       if (url_value->IsType(Value::TYPE_STRING)) {
         std::string url_string;
         url_value->GetAsString(&url_string);
         url_strings.push_back(url_string);
       } else if (url_value->IsType(Value::TYPE_LIST)) {
-        const ListValue* url_list = static_cast<const ListValue*>(url_value);
+        const base::ListValue* url_list =
+            static_cast<const base::ListValue*>(url_value);
         for (size_t i = 0; i < url_list->GetSize(); ++i) {
           std::string url_string;
           EXTENSION_FUNCTION_VALIDATE(url_list->GetString(i, &url_string));
           url_strings.push_back(url_string);
         }
       }
 
       // Second, resolve, validate and convert them to GURLs.
       for (std::vector<std::string>::iterator i = url_strings.begin();
            i != url_strings.end(); ++i) {
@@ skipping 251 matching lines @@
         new_window->extension_window_controller()->CreateWindowValueWithTabs(
             GetExtension()));
   }
 
   return true;
 }
 
 bool WindowsUpdateFunction::RunImpl() {
   int window_id = extension_misc::kUnknownWindowId;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
-  DictionaryValue* update_props;
+  base::DictionaryValue* update_props;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   WindowController* controller;
   if (!GetWindowFromWindowID(this, window_id, &controller))
     return false;
 
 #if defined(OS_WIN)
   // Silently ignore changes on the window for metro mode.
   if (win8::IsSingleWindowMetroMode()) {
     SetResult(controller->CreateWindowValue());
@@ skipping 227 matching lines @@
   if (params->query_info.index.get())
     index = *params->query_info.index;
 
   std::string window_type;
   if (params->query_info.window_type !=
       tabs::Query::Params::QueryInfo::WINDOW_TYPE_NONE) {
     window_type = tabs::Query::Params::QueryInfo::ToString(
         params->query_info.window_type);
   }
 
-  ListValue* result = new ListValue();
+  base::ListValue* result = new base::ListValue();
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
     if (!profile()->IsSameProfile(browser->profile()))
       continue;
 
     if (!browser->window())
       continue;
 
     if (!include_incognito() && profile() != browser->profile())
       continue;
@@ skipping 487 matching lines @@
   return true;
 }
 
 void TabsUpdateFunction::PopulateResult() {
   if (!has_callback())
     return;
 
   SetResult(ExtensionTabUtil::CreateTabValue(web_contents_, GetExtension()));
 }
 
-void TabsUpdateFunction::OnExecuteCodeFinished(const std::string& error,
-                                              int32 on_page_id,
-                                              const GURL& url,
-                                              const ListValue& script_result) {
+void TabsUpdateFunction::OnExecuteCodeFinished(
+    const std::string& error,
+    int32 on_page_id,
+    const GURL& url,
+    const base::ListValue& script_result) {
   if (error.empty())
     PopulateResult();
   else
     error_ = error;
   SendResponse(error.empty());
 }
 
 bool TabsMoveFunction::RunImpl() {
   scoped_ptr<tabs::Move::Params> params(tabs::Move::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int new_index = params->move_properties.index;
   int* window_id = params->move_properties.window_id.get();
-  ListValue tab_values;
+  base::ListValue tab_values;
 
   std::vector<int> tab_ids;
   if (params->tab_ids.as_array.get()) {
     tab_ids = *params->tab_ids.as_array;
 
     for (size_t i = 0; i < tab_ids.size(); ++i) {
       if (!MoveTab(tab_ids[i], &new_index, i, &tab_values, window_id)) {
         return false;
       }
     }
@@ skipping 18 matching lines @@
     Value* value = NULL;
     CHECK(tab_values.Get(0, &value));
     SetResult(value->DeepCopy());
   }
   return true;
 }
 
 bool TabsMoveFunction::MoveTab(int tab_id,
                                int *new_index,
                                int iteration,
-                               ListValue* tab_values,
+                               base::ListValue* tab_values,
                                int* window_id) {
   Browser* source_browser = NULL;
   TabStripModel* source_tab_strip = NULL;
   WebContents* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   &source_browser, &source_tab_strip, &contents,
                   &tab_index, &error_)) {
     return false;
   }
@@ skipping 502 matching lines @@
 }
 
 bool ExecuteCodeInTabFunction::IsWebView() const {
   return false;
 }
 
 bool TabsExecuteScriptFunction::ShouldInsertCSS() const {
   return false;
 }
 
-void TabsExecuteScriptFunction::OnExecuteCodeFinished(const std::string& error,
-                                                      int32 on_page_id,
-                                                      const GURL& on_url,
-                                                      const ListValue& result) {
+void TabsExecuteScriptFunction::OnExecuteCodeFinished(
+    const std::string& error,
+    int32 on_page_id,
+    const GURL& on_url,
+    const base::ListValue& result) {
   if (error.empty())
     SetResult(result.DeepCopy());
   ExecuteCodeInTabFunction::OnExecuteCodeFinished(error, on_page_id, on_url,
                                                   result);
 }
 
 bool ExecuteCodeInTabFunction::Init() {
   if (details_.get())
     return true;
 
   // |tab_id| is optional so it's ok if it's not there.
   int tab_id = -1;
   if (args_->GetInteger(0, &tab_id))
     EXTENSION_FUNCTION_VALIDATE(tab_id >= 0);
 
   // |details| are not optional.
-  DictionaryValue* details_value = NULL;
+  base::DictionaryValue* details_value = NULL;
   if (!args_->GetDictionary(1, &details_value))
     return false;
   scoped_ptr<InjectDetails> details(new InjectDetails());
   if (!InjectDetails::Populate(*details_value, details.get()))
     return false;
 
   // If the tab ID wasn't given then it needs to be converted to the
   // currently active tab's ID.
   if (tab_id == -1) {
     Browser* browser = GetCurrentBrowser();
     if (!browser)
       return false;
     content::WebContents* web_contents = NULL;
     if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, &tab_id))
       return false;
   }
 
   execute_tab_id_ = tab_id;
   details_ = details.Pass();
   return true;
 }
 
 bool TabsInsertCSSFunction::ShouldInsertCSS() const {
   return true;
 }
 
 }  // namespace extensions