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

chrome/browser/automation/testing_automation_provider.cc

 // Copyright 2013 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/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 638 matching lines @@
           this, browser, command, reply_message, false)) {
         chrome::ExecuteCommand(browser, command);
         return;
       }
     }
   }
   AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
-void TestingAutomationProvider::WebkitMouseClick(DictionaryValue* args,
+void TestingAutomationProvider::WebkitMouseClick(base::DictionaryValue* args,
                                                  IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
@@ skipping 29 matching lines @@
 
   view->ForwardMouseEvent(mouse_event);
 
   mouse_event.type = blink::WebInputEvent::MouseUp;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseMove(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
   mouse_event.type = blink::WebInputEvent::MouseMove;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
-void TestingAutomationProvider::WebkitMouseDrag(DictionaryValue* args,
+void TestingAutomationProvider::WebkitMouseDrag(base::DictionaryValue* args,
                                                 IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
@@ skipping 30 matching lines @@
 
   // Step 4 - Release the left mouse button.
   mouse_event.type = blink::WebInputEvent::MouseUp;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseButtonDown(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
   mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseButtonUp(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
   mouse_event.type = blink::WebInputEvent::MouseUp;
   mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseDoubleClick(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
@@ skipping 17 matching lines @@
 
   mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.clickCount = 2;
   view->ForwardMouseEvent(mouse_event);
 
   mouse_event.type = blink::WebInputEvent::MouseUp;
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::DragAndDropFilePaths(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   int x, y;
   if (!args->GetInteger("x", &x) || !args->GetInteger("y", &y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
-  ListValue* paths = NULL;
+  base::ListValue* paths = NULL;
   if (!args->GetList("paths", &paths)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'paths' missing or invalid");
     return;
   }
 
   // Emulate drag and drop to set the file paths to the file upload control.
   content::DropData drop_data;
   for (size_t path_index = 0; path_index < paths->GetSize(); ++path_index) {
     base::string16 path;
@@ skipping 137 matching lines @@
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   new BrowserOpenedWithNewProfileNotificationObserver(this, reply_message);
   profile_manager->CreateMultiProfileAsync(
       base::string16(), base::string16(), ProfileManager::CreateCallback(), std::string());
 }
 
 // Sample json input: { "command": "GetMultiProfileInfo" }
 // See GetMultiProfileInfo() in pyauto.py for sample output.
 void TestingAutomationProvider::GetMultiProfileInfo(
     base::DictionaryValue* args, IPC::Message* reply_message) {
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   const ProfileInfoCache& profile_info_cache =
       profile_manager->GetProfileInfoCache();
   return_value->SetBoolean("enabled", profiles::IsMultipleProfilesEnabled());
 
-  ListValue* profiles = new ListValue;
+  base::ListValue* profiles = new base::ListValue;
   for (size_t index = 0; index < profile_info_cache.GetNumberOfProfiles();
        ++index) {
-    DictionaryValue* item = new DictionaryValue;
+    base::DictionaryValue* item = new base::DictionaryValue;
     item->SetString("name", profile_info_cache.GetNameOfProfileAtIndex(index));
     item->SetString("path",
                     profile_info_cache.GetPathOfProfileAtIndex(index).value());
     profiles->Append(item);
   }
   return_value->Set("profiles", profiles);
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 void TestingAutomationProvider::OpenNewBrowserWindowOfType(
@@ skipping 23 matching lines @@
       Browser::CreateParams(Browser::TYPE_TABBED, profile_,
                             chrome::HOST_DESKTOP_TYPE_NATIVE));
   chrome::AddTabAt(browser, GURL(), -1, true);
   if (show)
     browser->window()->Show();
 }
 
 void TestingAutomationProvider::GetBrowserWindowCountJSON(
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   // The automation layer doesn't support non-native desktops.
   dict.SetInteger("count",
                   static_cast<int>(BrowserList::GetInstance(
                       chrome::HOST_DESKTOP_TYPE_NATIVE)->size()));
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::CloseBrowserWindow(
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
@@ skipping 78 matching lines @@
   if (browser) {
     FindBarTesting* find_bar =
         browser->GetFindBarController()->find_bar()->GetFindBarTesting();
     find_bar->GetFindBarWindowInfo(NULL, visible);
   }
 }
 
 // Bookmark bar visibility is based on the pref (e.g. is it in the toolbar).
 // Presence in the NTP is signalled in |detached|.
 void TestingAutomationProvider::GetBookmarkBarStatus(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   // browser->window()->IsBookmarkBarVisible() is not consistent across
   // platforms. bookmark_bar_state() also follows prefs::kShowBookmarkBar
   // and has a shared implementation on all platforms.
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("visible",
                   browser->bookmark_bar_state() == BookmarkBar::SHOW);
   dict.SetBoolean("animating", browser->window()->IsBookmarkBarAnimating());
   dict.SetBoolean("detached",
                   browser->bookmark_bar_state() == BookmarkBar::DETACHED);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::GetBookmarksAsJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg, bookmarks_as_json;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForProfile(browser->profile());
   if (!bookmark_model->loaded()) {
     reply.SendError("Bookmark model is not loaded");
     return;
   }
   scoped_refptr<BookmarkStorage> storage(
       new BookmarkStorage(browser->profile(),
                           bookmark_model,
                           browser->profile()->GetIOTaskRunner().get()));
   if (!storage->SerializeData(&bookmarks_as_json)) {
     reply.SendError("Failed to serialize bookmarks");
     return;
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetString("bookmarks_as_json", bookmarks_as_json);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::WaitForBookmarkModelToLoad(
     int handle,
     IPC::Message* reply_message) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     BookmarkModel* model =
         BookmarkModelFactory::GetForProfile(browser->profile());
     AutomationProviderBookmarkModelObserver* observer =
         new AutomationProviderBookmarkModelObserver(this, reply_message,
                                                     model, false);
     if (model->loaded()) {
       observer->ReleaseReply();
       delete observer;
       AutomationMsg_WaitForBookmarkModelToLoad::WriteReplyParams(
           reply_message, true);
       Send(reply_message);
     }
   }
 }
 
 void TestingAutomationProvider::WaitForBookmarkModelToLoadJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     AutomationJSONReply(this, reply_message).SendError(error_msg);
     return;
   }
   BookmarkModel* model =
       BookmarkModelFactory::GetForProfile(browser->profile());
   AutomationProviderBookmarkModelObserver* observer =
       new AutomationProviderBookmarkModelObserver(this, reply_message, model,
                                                   true);
   if (model->loaded()) {
     observer->ReleaseReply();
     delete observer;
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     return;
   }
 }
 
 void TestingAutomationProvider::AddBookmark(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg, url;
   base::string16 title;
   int parent_id, index;
   bool folder;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
@@ skipping 35 matching lines @@
   } else {
     child = model->AddURL(parent, index, title, GURL(url));
   }
   if (!child) {
     reply.SendError("Failed to add bookmark");
     return;
   }
   reply.SendSuccess(NULL);
 }
 
-void TestingAutomationProvider::ReparentBookmark(DictionaryValue* args,
+void TestingAutomationProvider::ReparentBookmark(base::DictionaryValue* args,
                                                  IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   int new_parent_id, id, index;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   if (!args->GetInteger("id", &id)) {
@@ skipping 21 matching lines @@
     return;
   }
   if (!new_parent) {
     reply.SendError("Failed to get new parent bookmark node");
     return;
   }
   model->Move(node, new_parent, index);
   reply.SendSuccess(NULL);
 }
 
-void TestingAutomationProvider::SetBookmarkTitle(DictionaryValue* args,
+void TestingAutomationProvider::SetBookmarkTitle(base::DictionaryValue* args,
                                                  IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   base::string16 title;
   int id;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
@@ skipping 13 matching lines @@
   }
   const BookmarkNode* node = model->GetNodeByID(id);
   if (!node) {
     reply.SendError("Failed to get bookmark node");
     return;
   }
   model->SetTitle(node, title);
   reply.SendSuccess(NULL);
 }
 
-void TestingAutomationProvider::SetBookmarkURL(DictionaryValue* args,
+void TestingAutomationProvider::SetBookmarkURL(base::DictionaryValue* args,
                                                IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg, url;
   int id;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   if (!args->GetInteger("id", &id)) {
@@ skipping 12 matching lines @@
   }
   const BookmarkNode* node = model->GetNodeByID(id);
   if (!node) {
     reply.SendError("Failed to get bookmark node");
     return;
   }
   model->SetURL(node, GURL(url));
   reply.SendSuccess(NULL);
 }
 
-void TestingAutomationProvider::RemoveBookmark(DictionaryValue* args,
+void TestingAutomationProvider::RemoveBookmark(base::DictionaryValue* args,
                                                IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   int id;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   if (!args->GetInteger("id", &id)) {
@@ skipping 388 matching lines @@
   browser_handler_map_["IsFullscreenBubbleDisplayed"] =
       &TestingAutomationProvider::IsFullscreenBubbleDisplayed;
   browser_handler_map_["IsFullscreenBubbleDisplayingButtons"] =
       &TestingAutomationProvider::IsFullscreenBubbleDisplayingButtons;
   browser_handler_map_["AcceptCurrentFullscreenOrMouseLockRequest"] =
       &TestingAutomationProvider::AcceptCurrentFullscreenOrMouseLockRequest;
   browser_handler_map_["DenyCurrentFullscreenOrMouseLockRequest"] =
       &TestingAutomationProvider::DenyCurrentFullscreenOrMouseLockRequest;
 }
 
-scoped_ptr<DictionaryValue> TestingAutomationProvider::ParseJSONRequestCommand(
+scoped_ptr<base::DictionaryValue>
+TestingAutomationProvider::ParseJSONRequestCommand(
     const std::string& json_request,
     std::string* command,
     std::string* error) {
-  scoped_ptr<DictionaryValue> dict_value;
-  scoped_ptr<Value> values(base::JSONReader::ReadAndReturnError(json_request,
-      base::JSON_ALLOW_TRAILING_COMMAS, NULL, error));
+  scoped_ptr<base::DictionaryValue> dict_value;
+  scoped_ptr<base::Value> values(
+      base::JSONReader::ReadAndReturnError(json_request,
+          base::JSON_ALLOW_TRAILING_COMMAS, NULL, error));
   if (values.get()) {
     // Make sure input is a dict with a string command.
-    if (values->GetType() != Value::TYPE_DICTIONARY) {
+    if (values->GetType() != base::Value::TYPE_DICTIONARY) {
       *error = "Command dictionary is not a dictionary.";
     } else {
-      dict_value.reset(static_cast<DictionaryValue*>(values.release()));
+      dict_value.reset(static_cast<base::DictionaryValue*>(values.release()));
       if (!dict_value->GetStringASCII("command", command)) {
         *error = "Command key string missing from dictionary.";
         dict_value.reset(NULL);
       }
     }
   }
   return dict_value.Pass();
 }
 
 void TestingAutomationProvider::SendJSONRequestWithBrowserHandle(
@@ skipping 21 matching lines @@
         "Browser window with index=%d does not exist.", index));
   } else {
     SendJSONRequest(browser, json_request, reply_message);
   }
 }
 
 void TestingAutomationProvider::SendJSONRequest(Browser* browser,
                                                 const std::string& json_request,
                                                 IPC::Message* reply_message) {
   std::string command, error_string;
-  scoped_ptr<DictionaryValue> dict_value(
+  scoped_ptr<base::DictionaryValue> dict_value(
       ParseJSONRequestCommand(json_request, &command, &error_string));
   if (!dict_value.get() || command.empty()) {
     AutomationJSONReply(this, reply_message).SendError(error_string);
     return;
   }
 
   if (handler_map_.empty() || browser_handler_map_.empty())
     BuildJSONHandlerMaps();
 
   // Look for command in handlers that take a Browser.
@@ skipping 14 matching lines @@
     }
     for (std::map<std::string, BrowserJsonHandler>::const_iterator it =
          browser_handler_map_.begin(); it != browser_handler_map_.end(); ++it) {
       error_string += it->first + ", ";
     }
     AutomationJSONReply(this, reply_message).SendError(error_string);
   }
 }
 
 void TestingAutomationProvider::BringBrowserToFrontJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   browser->window()->Activate();
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "SetWindowDimensions",
 //                      "x": 20,         # optional
 //                      "y": 20,         # optional
 //                      "width": 800,    # optional
 //                      "height": 600 }  # optional
 void TestingAutomationProvider::SetWindowDimensions(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   gfx::Rect rect = browser->window()->GetRestoredBounds();
   int x, y, width, height;
   if (args->GetInteger("x", &x))
     rect.set_x(x);
   if (args->GetInteger("y", &y))
     rect.set_y(y);
   if (args->GetInteger("width", &width))
     rect.set_width(width);
   if (args->GetInteger("height", &height))
     rect.set_height(height);
   browser->window()->SetBounds(rect);
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
-ListValue* TestingAutomationProvider::GetInfobarsInfo(WebContents* wc) {
+base::ListValue* TestingAutomationProvider::GetInfobarsInfo(WebContents* wc) {
   // Each infobar may have different properties depending on the type.
-  ListValue* infobars = new ListValue;
+  base::ListValue* infobars = new base::ListValue;
   InfoBarService* infobar_service = InfoBarService::FromWebContents(wc);
   for (size_t i = 0; i < infobar_service->infobar_count(); ++i) {
-    DictionaryValue* infobar_item = new DictionaryValue;
+    base::DictionaryValue* infobar_item = new base::DictionaryValue;
     InfoBarDelegate* infobar = infobar_service->infobar_at(i)->delegate();
     switch (infobar->GetInfoBarAutomationType()) {
       case InfoBarDelegate::CONFIRM_INFOBAR:
         infobar_item->SetString("type", "confirm_infobar");
         break;
       case InfoBarDelegate::PASSWORD_INFOBAR:
         infobar_item->SetString("type", "password_infobar");
         break;
       case InfoBarDelegate::RPH_INFOBAR:
         infobar_item->SetString("type", "rph_infobar");
         break;
       case InfoBarDelegate::UNKNOWN_INFOBAR:
         infobar_item->SetString("type", "unknown_infobar");
         break;
     }
     if (infobar->AsConfirmInfoBarDelegate()) {
       // Also covers ThemeInstalledInfoBarDelegate.
       ConfirmInfoBarDelegate* confirm_infobar =
         infobar->AsConfirmInfoBarDelegate();
       infobar_item->SetString("text", confirm_infobar->GetMessageText());
       infobar_item->SetString("link_text", confirm_infobar->GetLinkText());
-      ListValue* buttons_list = new ListValue;
+      base::ListValue* buttons_list = new base::ListValue;
       int buttons = confirm_infobar->GetButtons();
       if (buttons & ConfirmInfoBarDelegate::BUTTON_OK) {
-        StringValue* button_label = new StringValue(
+        base::StringValue* button_label = new base::StringValue(
             confirm_infobar->GetButtonLabel(
               ConfirmInfoBarDelegate::BUTTON_OK));
         buttons_list->Append(button_label);
       }
       if (buttons & ConfirmInfoBarDelegate::BUTTON_CANCEL) {
-        StringValue* button_label = new StringValue(
+        base::StringValue* button_label = new base::StringValue(
             confirm_infobar->GetButtonLabel(
               ConfirmInfoBarDelegate::BUTTON_CANCEL));
         buttons_list->Append(button_label);
       }
       infobar_item->Set("buttons", buttons_list);
     } else if (infobar->AsExtensionInfoBarDelegate()) {
       infobar_item->SetString("type", "extension_infobar");
     } else {
       infobar_item->SetString("type", "unknown_infobar");
     }
     infobars->Append(infobar_item);
   }
   return infobars;
 }
 
 // Sample json input: { "command": "PerformActionOnInfobar",
 //                      "action": "dismiss",
 //                      "infobar_index": 0,
 //                      "tab_index": 0 }
 // Sample output: {}
 void TestingAutomationProvider::PerformActionOnInfobar(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int tab_index;
   int infobar_index_int;
   std::string action;
   if (!args->GetInteger("tab_index", &tab_index) ||
       !args->GetInteger("infobar_index", &infobar_index_int) ||
       !args->GetString("action", &action)) {
     reply.SendError("Invalid or missing args");
     return;
@@ skipping 38 matching lines @@
   }
 
   reply.SendError("Invalid action");
 }
 
 namespace {
 
 // Gets info about BrowserChildProcessHost. Must run on IO thread to
 // honor the semantics of BrowserChildProcessHostIterator.
 // Used by AutomationProvider::GetBrowserInfo().
-void GetChildProcessHostInfo(ListValue* child_processes) {
+void GetChildProcessHostInfo(base::ListValue* child_processes) {
   for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
     // Only add processes which are already started, since we need their handle.
     if (iter.GetData().handle == base::kNullProcessHandle)
       continue;
-    DictionaryValue* item = new DictionaryValue;
+    base::DictionaryValue* item = new base::DictionaryValue;
     item->SetString("name", iter.GetData().name);
     item->SetString(
         "type",
         content::GetProcessTypeNameInEnglish(iter.GetData().process_type));
     item->SetInteger("pid", base::GetProcId(iter.GetData().handle));
     child_processes->Append(item);
   }
 }
 
 }  // namespace
 
 // Sample json input: { "command": "GetBrowserInfo" }
 // Refer to GetBrowserInfo() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetBrowserInfo(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;  // needed for PathService
-  DictionaryValue* properties = new DictionaryValue;
+  base::DictionaryValue* properties = new base::DictionaryValue;
   properties->SetString("ChromeVersion", chrome::kChromeVersion);
   properties->SetString("BrowserProcessExecutableName",
                         chrome::kBrowserProcessExecutableName);
   properties->SetString("HelperProcessExecutableName",
                         chrome::kHelperProcessExecutableName);
   properties->SetString("BrowserProcessExecutablePath",
                         chrome::kBrowserProcessExecutablePath);
   properties->SetString("HelperProcessExecutablePath",
                         chrome::kHelperProcessExecutablePath);
   properties->SetString("command_line_string",
@@ skipping 16 matching lines @@
   branding = "Unknown Branding";
 #endif
   properties->SetString("branding", branding);
 
   bool is_official_build = false;
 #if defined(OFFICIAL_BUILD)
   is_official_build = true;
 #endif
   properties->SetBoolean("is_official", is_official_build);
 
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->Set("properties", properties);
 
   return_value->SetInteger("browser_pid", base::GetCurrentProcId());
   // Add info about all windows in a list of dictionaries, one dictionary
   // item per window.
-  ListValue* windows = new ListValue;
+  base::ListValue* windows = new base::ListValue;
   int windex = 0;
 
   for (chrome::BrowserIterator it; !it.done(); it.Next(), ++windex) {
-    DictionaryValue* browser_item = new DictionaryValue;
+    base::DictionaryValue* browser_item = new base::DictionaryValue;
     Browser* browser = *it;
     browser_item->SetInteger("index", windex);
     // Window properties
     gfx::Rect rect = browser->window()->GetRestoredBounds();
     browser_item->SetInteger("x", rect.x());
     browser_item->SetInteger("y", rect.y());
     browser_item->SetInteger("width", rect.width());
     browser_item->SetInteger("height", rect.height());
     browser_item->SetBoolean("fullscreen",
                              browser->window()->IsFullscreen());
-    ListValue* visible_page_actions = new ListValue;
+    base::ListValue* visible_page_actions = new base::ListValue;
     // Add info about all visible page actions. Skipped on panels, which do not
     // have a location bar.
     LocationBar* loc_bar = browser->window()->GetLocationBar();
     if (loc_bar) {
       LocationBarTesting* loc_bar_test =
           loc_bar->GetLocationBarForTesting();
       size_t page_action_visible_count =
           static_cast<size_t>(loc_bar_test->PageActionVisibleCount());
       for (size_t i = 0; i < page_action_visible_count; ++i) {
-        StringValue* extension_id = new StringValue(
+        base::StringValue* extension_id = new base::StringValue(
             loc_bar_test->GetVisiblePageAction(i)->extension_id());
         visible_page_actions->Append(extension_id);
       }
     }
     browser_item->Set("visible_page_actions", visible_page_actions);
     browser_item->SetInteger("selected_tab",
                              browser->tab_strip_model()->active_index());
     browser_item->SetBoolean("incognito",
                              browser->profile()->IsOffTheRecord());
     browser_item->SetString("profile_path",
         browser->profile()->GetPath().BaseName().MaybeAsASCII());
     std::string type;
     switch (browser->type()) {
       case Browser::TYPE_TABBED:
         type = "tabbed";
         break;
       case Browser::TYPE_POPUP:
         type = "popup";
         break;
       default:
         type = "unknown";
         break;
     }
     browser_item->SetString("type", type);
     // For each window, add info about all tabs in a list of dictionaries,
     // one dictionary item per tab.
-    ListValue* tabs = new ListValue;
+    base::ListValue* tabs = new base::ListValue;
     for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
       WebContents* wc = browser->tab_strip_model()->GetWebContentsAt(i);
-      DictionaryValue* tab = new DictionaryValue;
+      base::DictionaryValue* tab = new base::DictionaryValue;
       tab->SetInteger("index", i);
       tab->SetString("url", wc->GetURL().spec());
       tab->SetInteger("renderer_pid",
                       base::GetProcId(wc->GetRenderProcessHost()->GetHandle()));
       tab->Set("infobars", GetInfobarsInfo(wc));
       tab->SetBoolean("pinned", browser->tab_strip_model()->IsTabPinned(i));
       tabs->Append(tab);
     }
     browser_item->Set("tabs", tabs);
 
     windows->Append(browser_item);
   }
   return_value->Set("windows", windows);
 
 #if defined(OS_LINUX)
   int flags = ChildProcessHost::CHILD_ALLOW_SELF;
 #else
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
 
   // Add all extension processes in a list of dictionaries, one dictionary
   // item per extension process.
-  ListValue* extension_views = new ListValue;
+  base::ListValue* extension_views = new base::ListValue;
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   std::vector<Profile*> profiles(profile_manager->GetLoadedProfiles());
   for (size_t i = 0; i < profiles.size(); ++i) {
     extensions::ProcessManager* process_manager =
         extensions::ExtensionSystem::Get(profiles[i])->process_manager();
     if (!process_manager)
       continue;
     const extensions::ProcessManager::ViewSet view_set =
         process_manager->GetAllViews();
     for (extensions::ProcessManager::ViewSet::const_iterator jt =
              view_set.begin();
          jt != view_set.end(); ++jt) {
       content::RenderViewHost* render_view_host = *jt;
       // Don't add dead extension processes.
       if (!render_view_host->IsRenderViewLive())
         continue;
       // Don't add views for which we can't obtain an extension.
       // TODO(benwells): work out why this happens. It only happens for one
       // test, and only on the bots.
       const Extension* extension =
           process_manager->GetExtensionForRenderViewHost(render_view_host);
       if (!extension)
         continue;
-      DictionaryValue* item = new DictionaryValue;
+      base::DictionaryValue* item = new base::DictionaryValue;
       item->SetString("name", extension->name());
       item->SetString("extension_id", extension->id());
       item->SetInteger(
           "pid",
           base::GetProcId(render_view_host->GetProcess()->GetHandle()));
-      DictionaryValue* view = new DictionaryValue;
+      base::DictionaryValue* view = new base::DictionaryValue;
       view->SetInteger(
           "render_process_id",
           render_view_host->GetProcess()->GetID());
       view->SetInteger(
           "render_view_id",
           render_view_host->GetRoutingID());
       item->Set("view", view);
       std::string type;
       WebContents* web_contents =
           WebContents::FromRenderViewHost(render_view_host);
@@ skipping 27 matching lines @@
       extension_views->Append(item);
     }
   }
   return_value->Set("extension_views", extension_views);
 
   return_value->SetString("child_process_path",
                           ChildProcessHost::GetChildPath(flags).value());
   // Child processes are the processes for plugins and other workers.
   // Add all child processes in a list of dictionaries, one dictionary item
   // per child process.
-  ListValue* child_processes = new ListValue;
+  base::ListValue* child_processes = new base::ListValue;
   return_value->Set("child_processes", child_processes);
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&GetChildProcessHostInfo, child_processes),
       base::Bind(&AutomationJSONReply::SendSuccess,
                  base::Owned(new AutomationJSONReply(this, reply_message)),
                  base::Owned(return_value.release())));
 }
 
 // Sample json input: { "command": "GetProcessInfo" }
 // Refer to GetProcessInfo() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetProcessInfo(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   scoped_refptr<ProcessInfoObserver>
       proc_observer(new ProcessInfoObserver(this, reply_message));
   // TODO(jamescook): Maybe this shouldn't update UMA stats?
   proc_observer->StartFetch(MemoryDetails::UPDATE_USER_METRICS);
 }
 
 // Sample json input: { "command": "GetNavigationInfo" }
 // Refer to GetNavigationInfo() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetNavigationInfo(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int tab_index;
   WebContents* web_contents = NULL;
   if (!args->GetInteger("tab_index", &tab_index) ||
       !(web_contents =
             browser->tab_strip_model()->GetWebContentsAt(tab_index))) {
     reply.SendError("tab_index missing or invalid.");
     return;
   }
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   const NavigationController& controller = web_contents->GetController();
   NavigationEntry* nav_entry = controller.GetActiveEntry();
   DCHECK(nav_entry);
 
   // Security info.
-  DictionaryValue* ssl = new DictionaryValue;
+  base::DictionaryValue* ssl = new base::DictionaryValue;
   std::map<content::SecurityStyle, std::string> style_to_string;
   style_to_string[content::SECURITY_STYLE_UNKNOWN] = "SECURITY_STYLE_UNKNOWN";
   style_to_string[content::SECURITY_STYLE_UNAUTHENTICATED] =
       "SECURITY_STYLE_UNAUTHENTICATED";
   style_to_string[content::SECURITY_STYLE_AUTHENTICATION_BROKEN] =
       "SECURITY_STYLE_AUTHENTICATION_BROKEN";
   style_to_string[content::SECURITY_STYLE_AUTHENTICATED] =
       "SECURITY_STYLE_AUTHENTICATED";
 
   SSLStatus ssl_status = nav_entry->GetSSL();
@@ skipping 15 matching lines @@
                           pagetype_to_string[nav_entry->GetPageType()]);
 
   return_value->SetString("favicon_url", nav_entry->GetFavicon().url.spec());
   reply.SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "GetHistoryInfo",
 //                      "search_text": "some text" }
 // Refer chrome/test/pyautolib/history_info.py for sample json output.
 void TestingAutomationProvider::GetHistoryInfo(Browser* browser,
-                                               DictionaryValue* args,
+                                               base::DictionaryValue* args,
                                                IPC::Message* reply_message) {
   consumer_.CancelAllRequests();
 
   base::string16 search_text;
   args->GetString("search_text", &search_text);
 
   // Fetch history.
   HistoryService* hs = HistoryServiceFactory::GetForProfile(
       browser->profile(), Profile::EXPLICIT_ACCESS);
   history::QueryOptions options;
   // The observer owns itself.  It deletes itself after it fetches history.
   AutomationProviderHistoryObserver* history_observer =
       new AutomationProviderHistoryObserver(this, reply_message);
   hs->QueryHistory(
       search_text,
       options,
       &consumer_,
       base::Bind(&AutomationProviderHistoryObserver::HistoryQueryComplete,
                  base::Unretained(history_observer)));
 }
 
 // Sample json input: { "command": "GetDownloadsInfo" }
 // Refer chrome/test/pyautolib/download_info.py for sample json output.
 void TestingAutomationProvider::GetDownloadsInfo(Browser* browser,
-                                                 DictionaryValue* args,
+                                                 base::DictionaryValue* args,
                                                  IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  ListValue* list_of_downloads = new ListValue;
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
+  base::ListValue* list_of_downloads = new base::ListValue;
 
   DownloadService* download_service(
       DownloadServiceFactory::GetForBrowserContext(browser->profile()));
 
   if (download_service->HasCreatedDownloadManager()) {
     std::vector<DownloadItem*> downloads;
     BrowserContext::GetDownloadManager(browser->profile())->GetAllDownloads(
         &downloads);
 
     for (std::vector<DownloadItem*>::iterator it = downloads.begin();
          it != downloads.end();
          it++) {  // Fill info about each download item.
       list_of_downloads->Append(GetDictionaryFromDownloadItem(
           *it, browser->profile()->IsOffTheRecord()));
     }
   }
   return_value->Set("downloads", list_of_downloads);
   reply.SendSuccess(return_value.get());
 }
 
 void TestingAutomationProvider::WaitForAllDownloadsToComplete(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  ListValue* pre_download_ids = NULL;
+  base::ListValue* pre_download_ids = NULL;
 
   if (!args->GetList("pre_download_ids", &pre_download_ids)) {
     AutomationJSONReply(this, reply_message)
         .SendError(
             base::StringPrintf("List of IDs of previous downloads required."));
     return;
   }
 
   DownloadService* download_service =
       DownloadServiceFactory::GetForBrowserContext(browser->profile());
   if (!download_service->HasCreatedDownloadManager()) {
     // No download manager, so no downloads to wait for.
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     return;
   }
 
   // This observer will delete itself.
   new AllDownloadsCompleteObserver(
       this, reply_message,
       BrowserContext::GetDownloadManager(browser->profile()),
       pre_download_ids);
 }
 
 // See PerformActionOnDownload() in chrome/test/pyautolib/pyauto.py for sample
 // json input and output.
 void TestingAutomationProvider::PerformActionOnDownload(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int id;
   std::string action;
 
   DownloadService* download_service =
       DownloadServiceFactory::GetForBrowserContext(browser->profile());
   if (!download_service->HasCreatedDownloadManager()) {
     AutomationJSONReply(this, reply_message).SendError("No download manager.");
     return;
   }
@@ skipping 77 matching lines @@
         this, reply_message, false, browser->profile()->IsOffTheRecord()));
     selected_item->Cancel(true);
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError(
             base::StringPrintf("Invalid action '%s' given.", action.c_str()));
   }
 }
 
 void TestingAutomationProvider::SetDownloadShelfVisibleJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   bool is_visible;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   if (!args->GetBoolean("is_visible", &is_visible)) {
     reply.SendError("'is_visible' missing or invalid.");
     return;
   }
   if (is_visible) {
     browser->window()->GetDownloadShelf()->Show();
   } else {
     browser->window()->GetDownloadShelf()->Close(DownloadShelf::AUTOMATIC);
   }
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::IsDownloadShelfVisibleJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("is_visible", browser->window()->IsDownloadShelfVisible());
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::GetDownloadDirectoryJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   WebContents* web_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
     reply.SendError(error);
     return;
   }
   DownloadManager* dlm =
       BrowserContext::GetDownloadManager(
           web_contents->GetController().GetBrowserContext());
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetString("path",
       DownloadPrefs::FromDownloadManager(dlm)->DownloadPath().value());
   reply.SendSuccess(&dict);
 }
 
 // Sample JSON input { "command": "LoadSearchEngineInfo" }
 void TestingAutomationProvider::LoadSearchEngineInfo(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
   if (url_model->loaded()) {
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     return;
   }
   url_model->AddObserver(new AutomationProviderSearchEngineObserver(
       this, browser->profile(), reply_message));
   url_model->Load();
 }
 
 // Sample JSON input { "command": "GetSearchEngineInfo" }
 // Refer to pyauto.py for sample output.
 void TestingAutomationProvider::GetSearchEngineInfo(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  ListValue* search_engines = new ListValue;
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
+  base::ListValue* search_engines = new base::ListValue;
   TemplateURLService::TemplateURLVector template_urls =
       url_model->GetTemplateURLs();
   for (TemplateURLService::TemplateURLVector::const_iterator it =
        template_urls.begin(); it != template_urls.end(); ++it) {
-    DictionaryValue* search_engine = new DictionaryValue;
+    base::DictionaryValue* search_engine = new base::DictionaryValue;
     search_engine->SetString("short_name", UTF16ToUTF8((*it)->short_name()));
     search_engine->SetString("keyword", UTF16ToUTF8((*it)->keyword()));
     search_engine->SetBoolean("in_default_list", (*it)->ShowInDefaultList());
     search_engine->SetBoolean("is_default",
         (*it) == url_model->GetDefaultSearchProvider());
     search_engine->SetBoolean("is_valid", (*it)->url_ref().IsValid());
     search_engine->SetBoolean("supports_replacement",
                               (*it)->url_ref().SupportsReplacement());
     search_engine->SetString("url", (*it)->url());
     search_engine->SetString("host", (*it)->url_ref().GetHost());
     search_engine->SetString("path", (*it)->url_ref().GetPath());
     search_engine->SetString("display_url",
                              UTF16ToUTF8((*it)->url_ref().DisplayURL()));
     search_engines->Append(search_engine);
   }
   return_value->Set("search_engines", search_engines);
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Refer to pyauto.py for sample JSON input.
 void TestingAutomationProvider::AddOrEditSearchEngine(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
   base::string16 new_title;
   base::string16 new_keyword;
   std::string new_url;
   std::string keyword;
   if (!args->GetString("new_title", &new_title) ||
       !args->GetString("new_keyword", &new_keyword) ||
       !args->GetString("new_url", &new_url)) {
@@ skipping 21 matching lines @@
     url_model->AddObserver(new AutomationProviderSearchEngineObserver(
         this, browser->profile(), reply_message));
     controller->AddTemplateURL(new_title, new_keyword, new_ref_url);
   }
 }
 
 // Sample json input: { "command": "PerformActionOnSearchEngine",
 //                      "keyword": keyword, "action": action }
 void TestingAutomationProvider::PerformActionOnSearchEngine(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
   std::string keyword;
   std::string action;
   if (!args->GetString("keyword", &keyword) ||
       !args->GetString("action", &action)) {
     AutomationJSONReply(this, reply_message).SendError(
         "One or more inputs invalid");
     return;
@@ skipping 15 matching lines @@
     url_model->SetDefaultSearchProvider(template_url);
   } else {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid action: " + action);
   }
 }
 
 // Sample json input: { "command": "GetLocalStatePrefsInfo" }
 // Refer chrome/test/pyautolib/prefs_info.py for sample json output.
 void TestingAutomationProvider::GetLocalStatePrefsInfo(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  scoped_ptr<DictionaryValue> items(
+  scoped_ptr<base::DictionaryValue> items(
       g_browser_process->local_state()->GetPreferenceValues());
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->Set("prefs", items.release());  // return_value owns items.
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "SetLocalStatePrefs", "path": path,
 //                      "value": value }
 void TestingAutomationProvider::SetLocalStatePrefs(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string path;
-  Value* val = NULL;
+  base::Value* val = NULL;
   AutomationJSONReply reply(this, reply_message);
   if (args->GetString("path", &path) && args->Get("value", &val)) {
     PrefService* pref_service = g_browser_process->local_state();
     const PrefService::Preference* pref =
         pref_service->FindPreference(path.c_str());
     if (!pref) {  // Not a registered pref.
       reply.SendError("pref not registered.");
       return;
     } else if (pref->IsManaged()) {  // Do not attempt to change a managed pref.
       reply.SendError("pref is managed. cannot be changed.");
       return;
     } else {  // Set the pref.
       pref_service->Set(path.c_str(), *val);
     }
   } else {
     reply.SendError("no pref path or value given.");
     return;
   }
 
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "GetPrefsInfo", "windex": 0 }
 // Refer chrome/test/pyautolib/prefs_info.py for sample json output.
-void TestingAutomationProvider::GetPrefsInfo(DictionaryValue* args,
+void TestingAutomationProvider::GetPrefsInfo(base::DictionaryValue* args,
                                              IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
-  scoped_ptr<DictionaryValue> items(
+  scoped_ptr<base::DictionaryValue> items(
       browser->profile()->GetPrefs()->GetPreferenceValues());
 
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->Set("prefs", items.release());  // return_value owns items.
   reply.SendSuccess(return_value.get());
 }
 
 // Sample json input:
 // { "command": "SetPrefs",
 //   "windex": 0,
 //   "path": path,
 //   "value": value }
-void TestingAutomationProvider::SetPrefs(DictionaryValue* args,
+void TestingAutomationProvider::SetPrefs(base::DictionaryValue* args,
                                          IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   std::string path;
-  Value* val = NULL;
+  base::Value* val = NULL;
   if (args->GetString("path", &path) && args->Get("value", &val)) {
     PrefService* pref_service = browser->profile()->GetPrefs();
     const PrefService::Preference* pref =
         pref_service->FindPreference(path.c_str());
     if (!pref) {  // Not a registered pref.
       reply.SendError("pref not registered.");
       return;
     } else if (pref->IsManaged()) {  // Do not attempt to change a managed pref.
       reply.SendError("pref is managed. cannot be changed.");
       return;
     } else {  // Set the pref.
       pref_service->Set(path.c_str(), *val);
     }
   } else {
     reply.SendError("no pref path or value given.");
     return;
   }
 
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "GetOmniboxInfo" }
 // Refer chrome/test/pyautolib/omnibox_info.py for sample json output.
 void TestingAutomationProvider::GetOmniboxInfo(Browser* browser,
-                                               DictionaryValue* args,
+                                               base::DictionaryValue* args,
                                                IPC::Message* reply_message) {
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   AutomationJSONReply reply(this, reply_message);
 
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   if (!loc_bar) {
     reply.SendError("The specified browser does not have a location bar.");
     return;
   }
   const OmniboxView* omnibox_view = loc_bar->GetOmniboxView();
   const OmniboxEditModel* model = omnibox_view->model();
 
   // Fill up matches.
-  ListValue* matches = new ListValue;
+  base::ListValue* matches = new base::ListValue;
   const AutocompleteResult& result = model->result();
   for (AutocompleteResult::const_iterator i(result.begin()); i != result.end();
        ++i) {
     const AutocompleteMatch& match = *i;
-    DictionaryValue* item = new DictionaryValue;  // owned by return_value
+    base::DictionaryValue* item =
+        new base::DictionaryValue;  // owned by return_value
     item->SetString("type", AutocompleteMatchType::ToString(match.type));
     item->SetBoolean("starred", match.starred);
     item->SetString("destination_url", match.destination_url.spec());
     item->SetString("contents", match.contents);
     item->SetString("description", match.description);
     matches->Append(item);
   }
   return_value->Set("matches", matches);
 
   // Fill up other properties.
-  DictionaryValue* properties = new DictionaryValue;  // owned by return_value
+  base::DictionaryValue* properties =
+      new base::DictionaryValue;  // owned by return_value
   properties->SetBoolean("has_focus", model->has_focus());
   properties->SetBoolean("query_in_progress",
                          !model->autocomplete_controller()->done());
   properties->SetString("keyword", model->keyword());
   properties->SetString("text", omnibox_view->GetText());
   return_value->Set("properties", properties);
 
   reply.SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "SetOmniboxText",
 //                      "text": "goog" }
 void TestingAutomationProvider::SetOmniboxText(Browser* browser,
-                                               DictionaryValue* args,
+                                               base::DictionaryValue* args,
                                                IPC::Message* reply_message) {
   base::string16 text;
   AutomationJSONReply reply(this, reply_message);
   if (!args->GetString("text", &text)) {
     reply.SendError("text missing");
     return;
   }
   chrome::FocusLocationBar(browser);
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   if (!loc_bar) {
     reply.SendError("The specified browser does not have a location bar.");
     return;
   }
   OmniboxView* omnibox_view = loc_bar->GetOmniboxView();
   omnibox_view->model()->OnSetFocus(false);
   omnibox_view->SetUserText(text);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "OmniboxMovePopupSelection",
 //                      "count": 1 }
 // Negative count implies up, positive implies down. Count values will be
 // capped by the size of the popup list.
 void TestingAutomationProvider::OmniboxMovePopupSelection(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int count;
   AutomationJSONReply reply(this, reply_message);
   if (!args->GetInteger("count", &count)) {
     reply.SendError("count missing");
     return;
   }
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   if (!loc_bar) {
     reply.SendError("The specified browser does not have a location bar.");
     return;
   }
   loc_bar->GetOmniboxView()->model()->OnUpOrDownKeyPressed(count);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "OmniboxAcceptInput" }
 void TestingAutomationProvider::OmniboxAcceptInput(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   NavigationController& controller =
       browser->tab_strip_model()->GetActiveWebContents()->GetController();
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   if (!loc_bar) {
     AutomationJSONReply(this, reply_message).SendError(
         "The specified browser does not have a location bar.");
     return;
   }
   new OmniboxAcceptNotificationObserver(&controller, this, reply_message);
   loc_bar->AcceptInput();
 }
 
 // Sample json input: { "command": "GetInitialLoadTimes" }
 // Refer to InitialLoadObserver::GetTimingInformation() for sample output.
 void TestingAutomationProvider::GetInitialLoadTimes(
     Browser*,
-    DictionaryValue*,
+    base::DictionaryValue*,
     IPC::Message* reply_message) {
-  scoped_ptr<DictionaryValue> return_value(
+  scoped_ptr<base::DictionaryValue> return_value(
       initial_load_observer_->GetTimingInformation());
 
   std::string json_return;
   base::JSONWriter::Write(return_value.get(), &json_return);
   AutomationMsg_SendJSONRequest::WriteReplyParams(
       reply_message, json_return, true);
   Send(reply_message);
 }
 
 // Sample json input: { "command": "GetPluginsInfo" }
 // Refer chrome/test/pyautolib/plugins_info.py for sample json output.
 void TestingAutomationProvider::GetPluginsInfo(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   PluginService::GetInstance()->GetPlugins(
       base::Bind(&TestingAutomationProvider::GetPluginsInfoCallback,
           this, browser, args, reply_message));
 }
 
 void TestingAutomationProvider::GetPluginsInfoCallback(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message,
     const std::vector<content::WebPluginInfo>& plugins) {
   PluginPrefs* plugin_prefs =
       PluginPrefs::GetForProfile(browser->profile()).get();
-  ListValue* items = new ListValue;
+  base::ListValue* items = new base::ListValue;
   for (std::vector<content::WebPluginInfo>::const_iterator it =
            plugins.begin();
        it != plugins.end();
        ++it) {
-    DictionaryValue* item = new DictionaryValue;
+    base::DictionaryValue* item = new base::DictionaryValue;
     item->SetString("name", it->name);
     item->SetString("path", it->path.value());
     item->SetString("version", it->version);
     item->SetString("desc", it->desc);
     item->SetBoolean("enabled", plugin_prefs->IsPluginEnabled(*it));
     // Add info about mime types.
-    ListValue* mime_types = new ListValue();
+    base::ListValue* mime_types = new base::ListValue();
     for (std::vector<content::WebPluginMimeType>::const_iterator type_it =
              it->mime_types.begin();
          type_it != it->mime_types.end();
          ++type_it) {
-      DictionaryValue* mime_type = new DictionaryValue();
+      base::DictionaryValue* mime_type = new base::DictionaryValue();
       mime_type->SetString("mimeType", type_it->mime_type);
       mime_type->SetString("description", type_it->description);
 
-      ListValue* file_extensions = new ListValue();
+      base::ListValue* file_extensions = new base::ListValue();
       for (std::vector<std::string>::const_iterator ext_it =
                type_it->file_extensions.begin();
            ext_it != type_it->file_extensions.end();
            ++ext_it) {
-        file_extensions->Append(new StringValue(*ext_it));
+        file_extensions->Append(new base::StringValue(*ext_it));
       }
       mime_type->Set("fileExtensions", file_extensions);
 
       mime_types->Append(mime_type);
     }
     item->Set("mimeTypes", mime_types);
     items->Append(item);
   }
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->Set("plugins", items);  // return_value owns items.
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input:
 //    { "command": "EnablePlugin",
 //      "path": "/Library/Internet Plug-Ins/Flash Player.plugin" }
 void TestingAutomationProvider::EnablePlugin(Browser* browser,
-                                             DictionaryValue* args,
+                                             base::DictionaryValue* args,
                                              IPC::Message* reply_message) {
   base::FilePath::StringType path;
   if (!args->GetString("path", &path)) {
     AutomationJSONReply(this, reply_message).SendError("path not specified.");
     return;
   }
   PluginPrefs* plugin_prefs =
       PluginPrefs::GetForProfile(browser->profile()).get();
   plugin_prefs->EnablePlugin(
       true,
       base::FilePath(path),
       base::Bind(&DidEnablePlugin,
                  AsWeakPtr(),
                  reply_message,
                  path,
                  "Could not enable plugin for path %s."));
 }
 
 // Sample json input:
 //    { "command": "DisablePlugin",
 //      "path": "/Library/Internet Plug-Ins/Flash Player.plugin" }
 void TestingAutomationProvider::DisablePlugin(Browser* browser,
-                                              DictionaryValue* args,
+                                              base::DictionaryValue* args,
                                               IPC::Message* reply_message) {
   base::FilePath::StringType path;
   if (!args->GetString("path", &path)) {
     AutomationJSONReply(this, reply_message).SendError("path not specified.");
     return;
   }
   PluginPrefs* plugin_prefs =
       PluginPrefs::GetForProfile(browser->profile()).get();
   plugin_prefs->EnablePlugin(
       false,
       base::FilePath(path),
       base::Bind(&DidEnablePlugin,
                  AsWeakPtr(),
                  reply_message,
                  path,
                  "Could not disable plugin for path %s."));
 }
 
 // Sample json input:
 //    { "command": "SaveTabContents",
 //      "tab_index": 0,
 //      "filename": <a full pathname> }
 // Sample json output:
 //    {}
 void TestingAutomationProvider::SaveTabContents(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int tab_index = 0;
   base::FilePath::StringType filename;
   base::FilePath::StringType parent_directory;
   WebContents* web_contents = NULL;
 
   if (!args->GetInteger("tab_index", &tab_index) ||
       !args->GetString("filename", &filename)) {
     AutomationJSONReply(this, reply_message)
         .SendError("tab_index or filename param missing");
@@ skipping 19 matching lines @@
   // The observer will delete itself when done.
   new SavePackageNotificationObserver(
       BrowserContext::GetDownloadManager(browser->profile()),
       this, reply_message);
 }
 
 namespace {
 
 // Translates a dictionary password to a PasswordForm struct.
 autofill::PasswordForm GetPasswordFormFromDict(
-    const DictionaryValue& password_dict) {
+    const base::DictionaryValue& password_dict) {
 
   // If the time is specified, change time to the specified time.
   base::Time time = base::Time::Now();
   int it;
   double dt;
   if (password_dict.GetInteger("time", &it))
     time = base::Time::FromTimeT(it);
   else if (password_dict.GetDouble("time", &dt))
     time = base::Time::FromDoubleT(dt);
 
@@ skipping 40 matching lines @@
   return password_form;
 }
 
 }  // namespace
 
 // See AddSavedPassword() in chrome/test/functional/pyauto.py for sample json
 // input.
 // Sample json output: { "password_added": true }
 void TestingAutomationProvider::AddSavedPassword(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  DictionaryValue* password_dict = NULL;
+  base::DictionaryValue* password_dict = NULL;
   if (!args->GetDictionary("password", &password_dict)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Must specify a password dictionary.");
     return;
   }
 
   // The "signon realm" is effectively the primary key and must be included.
   // Check here before calling GetPasswordFormFromDict.
   if (!password_dict->HasKey("signon_realm")) {
     AutomationJSONReply(this, reply_message).SendError(
         "Password must include a value for 'signon_realm.'");
     return;
   }
 
   autofill::PasswordForm new_password =
       GetPasswordFormFromDict(*password_dict);
 
   // Use IMPLICIT_ACCESS since new passwords aren't added in incognito mode.
   PasswordStore* password_store = PasswordStoreFactory::GetForProfile(
       browser->profile(), Profile::IMPLICIT_ACCESS).get();
 
   // The password store does not exist for an incognito window.
   if (password_store == NULL) {
-    scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+    scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
     return_value->SetBoolean("password_added", false);
     AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
     return;
   }
 
   // This observer will delete itself.
   PasswordStoreLoginsChangedObserver* observer =
       new PasswordStoreLoginsChangedObserver(this, reply_message,
                                              PasswordStoreChange::ADD,
                                              "password_added");
   observer->Init();
   password_store->AddLogin(new_password);
 }
 
 // See RemoveSavedPassword() in chrome/test/functional/pyauto.py for sample
 // json input.
 // Sample json output: {}
 void TestingAutomationProvider::RemoveSavedPassword(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  DictionaryValue* password_dict = NULL;
+  base::DictionaryValue* password_dict = NULL;
 
   if (!args->GetDictionary("password", &password_dict)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Must specify a password dictionary.");
     return;
   }
 
   // The "signon realm" is effectively the primary key and must be included.
   // Check here before calling GetPasswordFormFromDict.
   if (!password_dict->HasKey("signon_realm")) {
@@ skipping 20 matching lines @@
   observer->Init();
 
   password_store->RemoveLogin(to_remove);
 }
 
 // Sample json input: { "command": "GetSavedPasswords" }
 // Refer to GetSavedPasswords() in chrome/test/pyautolib/pyauto.py for sample
 // json output.
 void TestingAutomationProvider::GetSavedPasswords(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   // Use EXPLICIT_ACCESS since saved passwords can be retrieved in
   // incognito mode.
   PasswordStore* password_store = PasswordStoreFactory::GetForProfile(
       browser->profile(), Profile::EXPLICIT_ACCESS).get();
 
   if (password_store == NULL) {
     AutomationJSONReply reply(this, reply_message);
     reply.SendError("Unable to get password store.");
     return;
   }
   password_store->GetAutofillableLogins(
       new AutomationProviderGetPasswordsObserver(this, reply_message));
   // Observer deletes itself after sending the result.
 }
 
 namespace {
 
 // Get the WebContents from a dictionary of arguments.
 WebContents* GetWebContentsFromDict(const Browser* browser,
-                                    const DictionaryValue* args,
+                                    const base::DictionaryValue* args,
                                     std::string* error_message) {
   int tab_index;
   if (!args->GetInteger("tab_index", &tab_index)) {
     *error_message = "Must include tab_index.";
     return NULL;
   }
 
   WebContents* web_contents =
       browser->tab_strip_model()->GetWebContentsAt(tab_index);
   if (!web_contents) {
     *error_message = base::StringPrintf("No tab at index %d.", tab_index);
     return NULL;
   }
   return web_contents;
 }
 
 }  // namespace
 
 void TestingAutomationProvider::FindInPage(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error_message;
   WebContents* web_contents =
       GetWebContentsFromDict(browser, args, &error_message);
   if (!web_contents) {
     AutomationJSONReply(this, reply_message).SendError(error_message);
     return;
   }
   base::string16 search_string;
   bool forward;
@@ skipping 22 matching lines @@
   SendFindRequest(web_contents,
                   true,
                   search_string,
                   forward,
                   match_case,
                   find_next,
                   reply_message);
 }
 
 void TestingAutomationProvider::OpenFindInPage(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   chrome::FindInPage(browser, false, false);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::IsFindInPageVisible(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   bool visible;
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   FindBarTesting* find_bar =
       browser->GetFindBarController()->find_bar()->GetFindBarTesting();
   find_bar->GetFindBarWindowInfo(NULL, &visible);
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("is_visible", visible);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::InstallExtension(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   base::FilePath::StringType path_string;
   bool with_ui;
   bool from_webstore = false;
   Browser* browser;
   content::WebContents* tab;
   std::string error_msg;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error_msg)) {
     AutomationJSONReply(this, reply_message).SendError(error_msg);
     return;
   }
@@ skipping 42 matching lines @@
       installer->Load(extension_path);
     }
   } else {
     AutomationJSONReply(this, reply_message).SendError(
         "Extensions service/process manager is not available");
   }
 }
 
 namespace {
 
-ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
+base::ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
   extensions::URLPatternSet pattern_set;
   if (effective_perm) {
     pattern_set =
         extensions::PermissionsData::GetEffectiveHostPermissions(ext);
   } else {
     pattern_set = ext->GetActivePermissions()->explicit_hosts();
   }
 
-  ListValue* permissions = new ListValue;
+  base::ListValue* permissions = new base::ListValue;
   for (extensions::URLPatternSet::const_iterator perm = pattern_set.begin();
        perm != pattern_set.end(); ++perm) {
-    permissions->Append(new StringValue(perm->GetAsString()));
+    permissions->Append(new base::StringValue(perm->GetAsString()));
   }
 
   return permissions;
 }
 
-ListValue* GetAPIPermissions(const Extension* ext) {
-  ListValue* permissions = new ListValue;
+base::ListValue* GetAPIPermissions(const Extension* ext) {
+  base::ListValue* permissions = new base::ListValue;
   std::set<std::string> perm_list =
       ext->GetActivePermissions()->GetAPIsAsStrings();
   for (std::set<std::string>::const_iterator perm = perm_list.begin();
        perm != perm_list.end(); ++perm) {
-    permissions->Append(new StringValue(perm->c_str()));
+    permissions->Append(new base::StringValue(perm->c_str()));
   }
   return permissions;
 }
 
 }  // namespace
 
 // Sample json input: { "command": "GetExtensionsInfo" }
 // See GetExtensionsInfo() in chrome/test/pyautolib/pyauto.py for sample json
 // output.
-void TestingAutomationProvider::GetExtensionsInfo(DictionaryValue* args,
+void TestingAutomationProvider::GetExtensionsInfo(base::DictionaryValue* args,
                                                   IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser->profile())->extension_service();
   if (!service) {
     reply.SendError("No extensions service.");
     return;
   }
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  ListValue* extensions_values = new ListValue;
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
+  base::ListValue* extensions_values = new base::ListValue;
   const extensions::ExtensionSet* extensions = service->extensions();
   const extensions::ExtensionSet* disabled_extensions =
       service->disabled_extensions();
   ExtensionList all;
   all.insert(all.end(),
              extensions->begin(),
              extensions->end());
   all.insert(all.end(),
              disabled_extensions->begin(),
              disabled_extensions->end());
   ExtensionActionManager* extension_action_manager =
       ExtensionActionManager::Get(browser->profile());
   for (ExtensionList::const_iterator it = all.begin();
        it != all.end(); ++it) {
     const Extension* extension = it->get();
     std::string id = extension->id();
-    DictionaryValue* extension_value = new DictionaryValue;
+    base::DictionaryValue* extension_value = new base::DictionaryValue;
     extension_value->SetString("id", id);
     extension_value->SetString("version", extension->VersionString());
     extension_value->SetString("name", extension->name());
     extension_value->SetString("public_key", extension->public_key());
     extension_value->SetString("description", extension->description());
     extension_value->SetString(
         "background_url",
         extensions::BackgroundInfo::GetBackgroundURL(extension).spec());
     extension_value->SetString("options_url",
         extensions::ManifestURL::GetOptionsPage(extension).spec());
@@ skipping 19 matching lines @@
     extensions_values->Append(extension_value);
   }
   return_value->Set("extensions", extensions_values);
   reply.SendSuccess(return_value.get());
 }
 
 // See UninstallExtensionById() in chrome/test/pyautolib/pyauto.py for sample
 // json input.
 // Sample json output: {}
 void TestingAutomationProvider::UninstallExtensionById(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   const Extension* extension;
   std::string error;
   Browser* browser;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!GetExtensionFromJSONArgs(
           args, "id", browser->profile(), &extension, &error)) {
@@ skipping 10 matching lines @@
 
   // Wait for a notification indicating that the extension with the given ID
   // has been uninstalled.  This observer will delete itself.
   new ExtensionUninstallObserver(this, reply_message, extension->id());
   service->UninstallExtension(extension->id(), false, NULL);
 }
 
 // See SetExtensionStateById() in chrome/test/pyautolib/pyauto.py
 // for sample json input.
 void TestingAutomationProvider::SetExtensionStateById(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   const Extension* extension;
   std::string error;
   Browser* browser;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!GetExtensionFromJSONArgs(
           args, "id", browser->profile(), &extension, &error)) {
@@ skipping 49 matching lines @@
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
   }
 
   extension_util::SetIsIncognitoEnabled(
       extension->id(), service, allow_in_incognito);
 }
 
 // See TriggerPageActionById() in chrome/test/pyautolib/pyauto.py
 // for sample json input.
 void TestingAutomationProvider::TriggerPageActionById(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error;
   Browser* browser;
   WebContents* tab;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   const Extension* extension;
   if (!GetEnabledExtensionFromJSONArgs(
@@ skipping 34 matching lines @@
     new ExtensionPopupObserver(
         this, reply_message, extension->id());
   } else {
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
   }
 }
 
 // See TriggerBrowserActionById() in chrome/test/pyautolib/pyauto.py
 // for sample json input.
 void TestingAutomationProvider::TriggerBrowserActionById(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error;
   Browser* browser;
   WebContents* tab;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   const Extension* extension;
   if (!GetEnabledExtensionFromJSONArgs(
@@ skipping 43 matching lines @@
   if (action->HasPopup(extensions::ExtensionTabUtil::GetTabId(tab))) {
     // This observer will delete itself.
     new ExtensionPopupObserver(
         this, reply_message, extension->id());
   } else {
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
   }
 }
 
 void TestingAutomationProvider::ActionOnSSLBlockingPage(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   WebContents* web_contents;
   bool proceed;
   std::string error;
   if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!args->GetBoolean("proceed", &proceed)) {
     AutomationJSONReply(this, reply_message).SendError(
@@ skipping 13 matching lines @@
         return;
       }
       ssl_blocking_page->DontProceed();
       AutomationJSONReply(this, reply_message).SendSuccess(NULL);
       return;
     }
   }
   AutomationJSONReply(this, reply_message).SendError(error);
 }
 
-void TestingAutomationProvider::GetSecurityState(DictionaryValue* args,
+void TestingAutomationProvider::GetSecurityState(base::DictionaryValue* args,
                                                  IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   WebContents* web_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
     reply.SendError(error);
     return;
   }
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetInteger("security_style",
                   static_cast<int>(entry->GetSSL().security_style));
   dict.SetInteger("ssl_cert_status",
                   static_cast<int>(entry->GetSSL().cert_status));
   dict.SetInteger("insecure_content_status",
                   static_cast<int>(entry->GetSSL().content_status));
   reply.SendSuccess(&dict);
 }
 
 // Sample json input: { "command": "UpdateExtensionsNow" }
 // Sample json output: {}
 void TestingAutomationProvider::UpdateExtensionsNow(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error;
   Browser* browser;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser->profile())->extension_service();
   if (!service) {
@@ skipping 60 matching lines @@
 
   content::GeolocationProvider::OverrideLocationForTesting(
       position,
       base::Bind(&SendSuccessIfAlive, AsWeakPtr(), reply_message));
 }
 
 // Refer to GetAllNotifications() in chrome/test/pyautolib/pyauto.py for
 // sample json input/output.
 void TestingAutomationProvider::GetAllNotifications(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   new GetAllNotificationsObserver(this, reply_message);
 }
 
 // Refer to CloseNotification() in chrome/test/pyautolib/pyauto.py for
 // sample json input.
 // Returns empty json message.
 void TestingAutomationProvider::CloseNotification(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int index;
   if (!args->GetInteger("index", &index)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'index' missing or invalid.");
     return;
   }
   BalloonNotificationUIManager* manager =
       BalloonNotificationUIManager::GetInstanceForTesting();
   BalloonCollection* collection = manager->balloon_collection();
@@ skipping 13 matching lines @@
     new NewNotificationBalloonObserver(this, reply_message);
   }
   manager->CancelById(balloons[index]->notification().notification_id());
 }
 
 // Refer to WaitForNotificationCount() in chrome/test/pyautolib/pyauto.py for
 // sample json input.
 // Returns empty json message.
 void TestingAutomationProvider::WaitForNotificationCount(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int count;
   if (!args->GetInteger("count", &count)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'count' missing or invalid.");
     return;
   }
   // This will delete itself when finished.
   new OnNotificationBalloonCountObserver(this, reply_message, count);
 }
 
 // Sample JSON input: { "command": "GetNTPInfo" }
 // For output, refer to chrome/test/pyautolib/ntp_model.py.
 void TestingAutomationProvider::GetNTPInfo(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   // This observer will delete itself.
   new NTPInfoObserver(this, reply_message);
 }
 
 void TestingAutomationProvider::RemoveNTPMostVisitedThumbnail(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string url;
   if (!args->GetString("url", &url)) {
     reply.SendError("Missing or invalid 'url' key.");
     return;
   }
   history::TopSites* top_sites = browser->profile()->GetTopSites();
   if (!top_sites) {
     reply.SendError("TopSites service is not initialized.");
     return;
   }
   top_sites->AddBlacklistedURL(GURL(url));
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::RestoreAllNTPMostVisitedThumbnails(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   history::TopSites* top_sites = browser->profile()->GetTopSites();
   if (!top_sites) {
     reply.SendError("TopSites service is not initialized.");
     return;
   }
   top_sites->ClearBlacklistedURLs();
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::KillRendererProcess(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int pid;
   uint32 kAccessFlags = base::kProcessAccessTerminate |
                         base::kProcessAccessWaitForTermination |
                         base::kProcessAccessQueryInformation;
 
   if (!args->GetInteger("pid", &pid)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'pid' key missing or invalid.");
     return;
   }
   base::ProcessHandle process;
   if (!base::OpenProcessHandleWithAccess(static_cast<base::ProcessId>(pid),
                                          kAccessFlags,
                                          &process)) {
     AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
         "Failed to open process handle for pid %d", pid));
     return;
   }
   new RendererProcessClosedObserver(this, reply_message);
   base::KillProcess(process, 0, false);
   base::CloseProcessHandle(process);
 }
 
 bool TestingAutomationProvider::BuildWebKeyEventFromArgs(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     std::string* error,
     NativeWebKeyboardEvent* event) {
   int type, modifiers;
   bool is_system_key;
   base::string16 unmodified_text, text;
   std::string key_identifier;
   if (!args->GetInteger("type", &type)) {
     *error = "'type' missing or invalid.";
     return false;
   }
@@ skipping 62 matching lines @@
   if (modifiers & automation::kMetaKeyMask)
     event->modifiers |= blink::WebInputEvent::MetaKey;
 
   event->isSystemKey = is_system_key;
   event->timeStampSeconds = base::Time::Now().ToDoubleT();
   event->skip_in_browser = true;
   return true;
 }
 
 void TestingAutomationProvider::SendWebkitKeyEvent(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   NativeWebKeyboardEvent event;
   // In the event of an error, BuildWebKeyEventFromArgs handles telling what
   // went wrong and sending the reply message; if it fails, we just have to
   // stop here.
   std::string error;
   if (!BuildWebKeyEventFromArgs(args, &error, &event)) {
@@ skipping 20 matching lines @@
       !dialog_queue->active_dialog()->IsJavaScriptModalDialog()) {
     *error_msg = "No JavaScriptModalDialog open";
     return NULL;
   }
   return static_cast<JavaScriptAppModalDialog*>(dialog_queue->active_dialog());
 }
 
 }  // namespace
 
 void TestingAutomationProvider::GetAppModalDialogMessage(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string error_msg;
   JavaScriptAppModalDialog* dialog = GetActiveJavaScriptModalDialog(&error_msg);
   if (!dialog) {
     reply.SendError(error_msg);
     return;
   }
-  DictionaryValue result_dict;
+  base::DictionaryValue result_dict;
   result_dict.SetString("message", UTF16ToUTF8(dialog->message_text()));
   reply.SendSuccess(&result_dict);
 }
 
 void TestingAutomationProvider::AcceptOrDismissAppModalDialog(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   bool accept;
   if (!args->GetBoolean("accept", &accept)) {
     reply.SendError("Missing or invalid 'accept'");
     return;
   }
 
   std::string error_msg;
   JavaScriptAppModalDialog* dialog = GetActiveJavaScriptModalDialog(&error_msg);
   if (!dialog) {
     reply.SendError(error_msg);
     return;
   }
   if (accept) {
     std::string prompt_text;
     if (args->GetString("prompt_text", &prompt_text))
       dialog->SetOverridePromptText(UTF8ToUTF16(prompt_text));
     dialog->native_dialog()->AcceptAppModalDialog();
   } else {
     dialog->native_dialog()->CancelAppModalDialog();
   }
   reply.SendSuccess(NULL);
 }
 
 // Sample JSON input: { "command": "LaunchApp",
 //                      "id": "ahfgeienlihckogmohjhadlkjgocpleb" }
 // Sample JSON output: {}
 void TestingAutomationProvider::LaunchApp(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string id;
   if (!args->GetString("id", &id)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Must include string id.");
     return;
   }
 
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser->profile())->extension_service();
@@ skipping 27 matching lines @@
                         launch_params.container);
   OpenApplication(launch_params);
 }
 
 // Sample JSON input: { "command": "SetAppLaunchType",
 //                      "id": "ahfgeienlihckogmohjhadlkjgocpleb",
 //                      "launch_type": "pinned" }
 // Sample JSON output: {}
 void TestingAutomationProvider::SetAppLaunchType(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
 
   std::string id;
   if (!args->GetString("id", &id)) {
     reply.SendError("Must include string id.");
     return;
   }
 
   std::string launch_type_str;
@@ skipping 36 matching lines @@
       service->extension_prefs(), extension->id(), launch_type);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "GetV8HeapStats",
 //                      "tab_index": 0 }
 // Refer to GetV8HeapStats() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetV8HeapStats(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   WebContents* web_contents;
   int tab_index;
 
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing 'tab_index' argument.");
     return;
   }
 
@@ skipping 12 matching lines @@
       base::GetProcId(render_view->GetProcess()->GetHandle()));
   render_view->Send(new ChromeViewMsg_GetV8HeapStats);
 }
 
 // Sample json input: { "command": "GetFPS",
 //                      "tab_index": 0 }
 // Refer to GetFPS() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetFPS(
     Browser* browser,
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   WebContents* web_contents;
   int tab_index;
 
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing 'tab_index' argument.");
     return;
   }
 
@@ skipping 11 matching lines @@
   new FPSObserver(
       this, reply_message,
       base::GetProcId(render_view->GetProcess()->GetHandle()),
       routing_id);
   render_view->Send(new ChromeViewMsg_GetFPS(routing_id));
 }
 
 void TestingAutomationProvider::IsFullscreenForBrowser(Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("result",
                   browser->fullscreen_controller()->IsFullscreenForBrowser());
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsFullscreenForTab(Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("result",
       browser->fullscreen_controller()->IsFullscreenForTabOrPending());
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsMouseLocked(Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("result", browser->tab_strip_model()->GetActiveWebContents()->
       GetRenderViewHost()->GetView()->IsMouseLocked());
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsMouseLockPermissionRequested(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   FullscreenExitBubbleType type =
       browser->fullscreen_controller()->GetFullscreenExitBubbleType();
   bool mouse_lock = false;
   fullscreen_bubble::PermissionRequestedByType(type, NULL, &mouse_lock);
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("result", mouse_lock);
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsFullscreenPermissionRequested(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   FullscreenExitBubbleType type =
       browser->fullscreen_controller()->GetFullscreenExitBubbleType();
   bool fullscreen = false;
   fullscreen_bubble::PermissionRequestedByType(type, &fullscreen, NULL);
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("result", fullscreen);
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsFullscreenBubbleDisplayed(Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   FullscreenExitBubbleType type =
       browser->fullscreen_controller()->GetFullscreenExitBubbleType();
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("result",
                   type != FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION);
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsFullscreenBubbleDisplayingButtons(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   FullscreenExitBubbleType type =
       browser->fullscreen_controller()->GetFullscreenExitBubbleType();
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("result", fullscreen_bubble::ShowButtonsForType(type));
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::AcceptCurrentFullscreenOrMouseLockRequest(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   browser->fullscreen_controller()->OnAcceptFullscreenPermission();
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::DenyCurrentFullscreenOrMouseLockRequest(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   browser->fullscreen_controller()->OnDenyFullscreenPermission();
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::WaitForTabToBeRestored(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   WebContents* web_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   NavigationController& controller = web_contents->GetController();
   new NavigationControllerRestoredObserver(this, &controller, reply_message);
 }
@@ skipping 31 matching lines @@
 
   // Send the reply while we can.
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 
   // Cause Address Sanitizer to abort this process.
   volatile int index = 5;
   AccessArray(testarray, &index);
 }
 
 void TestingAutomationProvider::GetIndicesFromTab(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int id_or_handle = 0;
   bool has_id = args->HasKey("tab_id");
   bool has_handle = args->HasKey("tab_handle");
   if (has_id && has_handle) {
     reply.SendError(
         "Both 'tab_id' and 'tab_handle' were specified. Only one is allowed");
     return;
   } else if (!has_id && !has_handle) {
@@ skipping 21 matching lines @@
   for (; !it.done(); it.Next(), ++browser_index) {
     Browser* browser = *it;
     for (int tab_index = 0;
          tab_index < browser->tab_strip_model()->count();
          ++tab_index) {
       WebContents* tab =
           browser->tab_strip_model()->GetWebContentsAt(tab_index);
       SessionTabHelper* session_tab_helper =
           SessionTabHelper::FromWebContents(tab);
       if (session_tab_helper->session_id().id() == id) {
-        DictionaryValue dict;
+        base::DictionaryValue dict;
         dict.SetInteger("windex", browser_index);
         dict.SetInteger("tab_index", tab_index);
         reply.SendSuccess(&dict);
         return;
       }
     }
   }
   reply.SendError("Could not find tab among current browser windows");
 }
 
 void TestingAutomationProvider::NavigateToURL(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   int navigation_count;
   std::string url, error;
   Browser* browser;
   WebContents* web_contents;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
@@ skipping 19 matching lines @@
   OpenURLParams params(
       GURL(url), content::Referrer(), CURRENT_TAB,
       content::PageTransitionFromInt(
           content::PAGE_TRANSITION_TYPED |
           content::PAGE_TRANSITION_FROM_ADDRESS_BAR),
       false);
   browser->OpenURLFromTab(web_contents, params);
 }
 
 void TestingAutomationProvider::GetActiveTabIndexJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   int tab_index = browser->tab_strip_model()->active_index();
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->SetInteger("tab_index", tab_index);
   reply.SendSuccess(return_value.get());
 }
 
-void TestingAutomationProvider::AppendTabJSON(DictionaryValue* args,
+void TestingAutomationProvider::AppendTabJSON(base::DictionaryValue* args,
                                               IPC::Message* reply_message) {
   TabAppendedNotificationObserver* observer = NULL;
   int append_tab_response = -1;
   Browser* browser;
   std::string error_msg, url;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     AutomationJSONReply(this, reply_message).SendError(error_msg);
     return;
   }
   if (!args->GetString("url", &url)) {
@@ skipping 14 matching lines @@
   if (!contents || append_tab_response < 0) {
     if (observer) {
       observer->ReleaseReply();
       delete observer;
     }
     AutomationJSONReply(this, reply_message).SendError("Failed to append tab.");
   }
 }
 
 void TestingAutomationProvider::WaitUntilNavigationCompletes(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   std::string error;
   Browser* browser;
   WebContents* web_contents;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   NavigationNotificationObserver* observer =
       new NavigationNotificationObserver(&web_contents->GetController(), this,
                                          reply_message, 1, true, true);
   if (!web_contents->IsLoading()) {
     observer->ConditionMet(AUTOMATION_MSG_NAVIGATION_SUCCESS);
     return;
   }
 }
 
 void TestingAutomationProvider::ExecuteJavascriptJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   base::string16 frame_xpath, javascript;
   std::string error;
   RenderViewHost* render_view;
   if (!GetRenderViewFromJSONArgs(args, profile(), &render_view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!args->GetString("frame_xpath", &frame_xpath)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'frame_xpath' missing or invalid");
     return;
   }
   if (!args->GetString("javascript", &javascript)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'javascript' missing or invalid");
     return;
   }
 
   new DomOperationMessageSender(this, reply_message, true);
   ExecuteJavascriptInRenderViewFrame(frame_xpath, javascript, reply_message,
                                      render_view);
 }
 
 void TestingAutomationProvider::ExecuteJavascriptInRenderView(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   base::string16 frame_xpath, javascript, extension_id, url_text;
   int render_process_id, render_view_id;
   if (!args->GetString("frame_xpath", &frame_xpath)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'frame_xpath' missing or invalid");
     return;
   }
   if (!args->GetString("javascript", &javascript)) {
     AutomationJSONReply(this, reply_message)
@@ skipping 18 matching lines @@
             "A RenderViewHost object was not found with the given view ID.");
     return;
   }
 
   new DomOperationMessageSender(this, reply_message, true);
   ExecuteJavascriptInRenderViewFrame(frame_xpath, javascript, reply_message,
                                      rvh);
 }
 
 void TestingAutomationProvider::AddDomEventObserver(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   AutomationJSONReply reply(this, reply_message);
   std::string event_name;
   int automation_id;
   bool recurring;
   if (!args->GetString("event_name", &event_name)) {
     reply.SendError("'event_name' missing or invalid");
     return;
   }
   if (!args->GetInteger("automation_id", &automation_id)) {
     reply.SendError("'automation_id' missing or invalid");
     return;
   }
   if (!args->GetBoolean("recurring", &recurring)) {
     reply.SendError("'recurring' missing or invalid");
     return;
   }
 
   if (!automation_event_queue_.get())
     automation_event_queue_.reset(new AutomationEventQueue);
 
   int observer_id = automation_event_queue_->AddObserver(
       new DomEventObserver(automation_event_queue_.get(), event_name,
                            automation_id, recurring));
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->SetInteger("observer_id", observer_id);
   reply.SendSuccess(return_value.get());
 }
 
 void TestingAutomationProvider::RemoveEventObserver(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int observer_id;
   if (!args->GetInteger("observer_id", &observer_id) ||
       !automation_event_queue_.get()) {
     reply.SendError("'observer_id' missing or invalid");
     return;
   }
   if (automation_event_queue_->RemoveObserver(observer_id)) {
     reply.SendSuccess(NULL);
     return;
   }
   reply.SendError("Invalid observer id.");
 }
 
 void TestingAutomationProvider::ClearEventQueue(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   automation_event_queue_.reset();
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::GetNextEvent(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   scoped_ptr<AutomationJSONReply> reply(
       new AutomationJSONReply(this, reply_message));
   int observer_id;
   bool blocking;
   if (!args->GetInteger("observer_id", &observer_id)) {
     reply->SendError("'observer_id' missing or invalid");
     return;
   }
   if (!args->GetBoolean("blocking", &blocking)) {
     reply->SendError("'blocking' missing or invalid");
     return;
   }
   if (!automation_event_queue_.get()) {
     reply->SendError(
         "No observers are attached to the queue. Did you create any?");
     return;
   }
 
   // The reply will be freed once a matching event is added to the queue.
   automation_event_queue_->GetNextEvent(reply.release(), observer_id, blocking);
 }
 
 void TestingAutomationProvider::GoForward(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   WebContents* web_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   NavigationController& controller = web_contents->GetController();
   if (!controller.CanGoForward()) {
-    DictionaryValue dict;
+    base::DictionaryValue dict;
     dict.SetBoolean("did_go_forward", false);
     AutomationJSONReply(this, reply_message).SendSuccess(&dict);
     return;
   }
   new NavigationNotificationObserver(&controller, this, reply_message,
                                      1, false, true);
   controller.GoForward();
 }
 
 void TestingAutomationProvider::ExecuteBrowserCommandAsyncJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int command;
   Browser* browser;
   std::string error;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     reply.SendError(error);
     return;
   }
   if (!args->GetInteger("accelerator", &command)) {
     reply.SendError("'accelerator' missing or invalid.");
     return;
   }
   if (!chrome::SupportsCommand(browser, command)) {
     reply.SendError(base::StringPrintf("Browser does not support command=%d.",
                                        command));
     return;
   }
   if (!chrome::IsCommandEnabled(browser, command)) {
     reply.SendError(base::StringPrintf(
         "Browser command=%d not enabled.", command));
     return;
   }
   chrome::ExecuteCommand(browser, command);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::ExecuteBrowserCommandJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int command;
   Browser* browser;
   std::string error;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!args->GetInteger("accelerator", &command)) {
     AutomationJSONReply(this, reply_message).SendError(
@@ skipping 22 matching lines @@
   if (ExecuteBrowserCommandObserver::CreateAndRegisterObserver(
       this, browser, command, reply_message, true)) {
     chrome::ExecuteCommand(browser, command);
     return;
   }
   AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
       "Unable to register observer for browser command=%d.", command));
 }
 
 void TestingAutomationProvider::IsMenuCommandEnabledJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   int command;
   Browser* browser;
   std::string error;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!args->GetInteger("accelerator", &command)) {
     AutomationJSONReply(this, reply_message).SendError(
         "'accelerator' missing or invalid.");
     return;
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("enabled", chrome::IsCommandEnabled(browser, command));
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::GetTabInfo(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   WebContents* tab;
   std::string error;
   if (GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
     NavigationEntry* entry = tab->GetController().GetActiveEntry();
     if (!entry) {
       reply.SendError("Unable to get active navigation entry");
       return;
     }
-    DictionaryValue dict;
+    base::DictionaryValue dict;
     dict.SetString("title", entry->GetTitleForDisplay(std::string()));
     dict.SetString("url", entry->GetVirtualURL().spec());
     reply.SendSuccess(&dict);
   } else {
     reply.SendError(error);
   }
 }
 
 void TestingAutomationProvider::GetTabCountJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     reply.SendError(error);
     return;
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetInteger("tab_count", browser->tab_strip_model()->count());
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::GoBack(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   WebContents* web_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   NavigationController& controller = web_contents->GetController();
   if (!controller.CanGoBack()) {
-    DictionaryValue dict;
+    base::DictionaryValue dict;
     dict.SetBoolean("did_go_back", false);
     AutomationJSONReply(this, reply_message).SendSuccess(&dict);
     return;
   }
   new NavigationNotificationObserver(&controller, this, reply_message,
                                      1, false, true);
   controller.GoBack();
 }
 
 void TestingAutomationProvider::ReloadJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   WebContents* web_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   NavigationController& controller = web_contents->GetController();
   new NavigationNotificationObserver(&controller, this, reply_message,
                                      1, false, true);
   controller.Reload(false);
 }
 
 void TestingAutomationProvider::GetCookiesJSON(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::GetCookiesJSON(this, args, reply_message);
 }
 
 void TestingAutomationProvider::DeleteCookieJSON(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::DeleteCookieJSON(this, args, reply_message);
 }
 
 void TestingAutomationProvider::SetCookieJSON(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::SetCookieJSON(this, args, reply_message);
 }
 
 void TestingAutomationProvider::GetCookiesInBrowserContext(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   WebContents* web_contents;
   std::string value, url_string;
   int windex, value_size;
   if (!args->GetInteger("windex", &windex)) {
     reply.SendError("'windex' missing or invalid.");
     return;
   }
   web_contents = automation_util::GetWebContentsAt(windex, 0);
@@ skipping 10 matching lines @@
     reply.SendError("Invalid url.");
     return;
   }
   automation_util::GetCookies(url, web_contents, &value_size, &value);
   if (value_size == -1) {
     reply.SendError(
         base::StringPrintf("Unable to retrieve cookies for url=%s.",
                            url_string.c_str()));
     return;
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetString("cookies", value);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::DeleteCookieInBrowserContext(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   WebContents* web_contents;
   std::string cookie_name, url_string;
   int windex;
   bool success = false;
   if (!args->GetInteger("windex", &windex)) {
     reply.SendError("'windex' missing or invalid.");
     return;
   }
@@ skipping 19 matching lines @@
   if (!success) {
     reply.SendError(
         base::StringPrintf("Failed to delete cookie with name=%s for url=%s.",
                            cookie_name.c_str(), url_string.c_str()));
     return;
   }
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::SetCookieInBrowserContext(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   WebContents* web_contents;
   std::string value, url_string;
   int windex, response_value = -1;
   if (!args->GetInteger("windex", &windex)) {
     reply.SendError("'windex' missing or invalid.");
     return;
   }
   web_contents = automation_util::GetWebContentsAt(windex, 0);
@@ skipping 17 matching lines @@
   automation_util::SetCookie(url, value, web_contents, &response_value);
   if (response_value != 1) {
     reply.SendError(base::StringPrintf(
         "Unable set cookie for url=%s.", url_string.c_str()));
     return;
   }
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::GetTabIds(
-    DictionaryValue* args, IPC::Message* reply_message) {
-  ListValue* id_list = new ListValue();
+    base::DictionaryValue* args, IPC::Message* reply_message) {
+  base::ListValue* id_list = new base::ListValue();
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
     for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
       int id = SessionTabHelper::FromWebContents(
           browser->tab_strip_model()->GetWebContentsAt(i))->session_id().id();
-      id_list->Append(Value::CreateIntegerValue(id));
+      id_list->Append(base::Value::CreateIntegerValue(id));
     }
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.Set("ids", id_list);
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsTabIdValid(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int id;
   if (!args->GetInteger("id", &id)) {
     reply.SendError("'id' missing or invalid");
     return;
   }
   bool is_valid = false;
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
     for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
       WebContents* tab = browser->tab_strip_model()->GetWebContentsAt(i);
       SessionTabHelper* session_tab_helper =
           SessionTabHelper::FromWebContents(tab);
       if (session_tab_helper->session_id().id() == id) {
         is_valid = true;
         break;
       }
     }
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("is_valid", is_valid);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::CloseTabJSON(
-    DictionaryValue* args, IPC::Message* reply_message) {
+    base::DictionaryValue* args, IPC::Message* reply_message) {
   Browser* browser;
   WebContents* tab;
   std::string error;
   bool wait_until_closed = false;  // ChromeDriver does not use this.
   args->GetBoolean("wait_until_closed", &wait_until_closed);
   // Close tabs synchronously.
   if (GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
     if (wait_until_closed) {
       new TabClosedNotificationObserver(this, wait_until_closed, reply_message,
                                         true);
@@ skipping 57 matching lines @@
 
   browser->window()->Maximize();
 
 #if !defined(OS_LINUX)
   // Send success reply right away for OS's with synchronous maximize command.
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 #endif  // !defined(OS_LINUX)
 }
 
 void TestingAutomationProvider::ActivateTabJSON(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   WebContents* web_contents;
   std::string error;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &web_contents, &error)) {
     reply.SendError(error);
@@ skipping 40 matching lines @@
   LocationBarTesting* loc_bar =
       browser->window()->GetLocationBar()->GetLocationBarForTesting();
   size_t page_action_visible_count =
       static_cast<size_t>(loc_bar->PageActionVisibleCount());
   for (size_t i = 0; i < page_action_visible_count; ++i) {
     if (loc_bar->GetVisiblePageAction(i) == page_action) {
       is_visible = true;
       break;
     }
   }
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.SetBoolean("is_visible", is_visible);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::CreateNewAutomationProvider(
-    DictionaryValue* args,
+    base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string channel_id;
   if (!args->GetString("channel_id", &channel_id)) {
     reply.SendError("'channel_id' missing or invalid");
     return;
   }
 
   AutomationProvider* provider = new TestingAutomationProvider(profile_);
   provider->DisableInitialLoadObservers();
@@ skipping 59 matching lines @@
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   TabStripModel* tab_strip = browser->tab_strip_model();
   if (tab_strip->GetActiveWebContents() != tab)
     tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents(tab), true);
 }