Allow the automation provider to accept an ID for performing render-view

chrome/browser/automation/testing_automation_provider.cc

 // Copyright (c) 2011 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 83 matching lines @@
 #include "chrome/browser/ui/bookmarks/bookmark_bar.h"
 #include "chrome/browser/ui/browser_init.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/find_bar/find_bar.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
 #include "chrome/browser/ui/search_engines/keyword_editor_controller.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/automation_id.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/extensions/url_pattern_set.h"
@@ skipping 811 matching lines @@
                              ui::EF_ALT_DOWN),
                             ((flags & ui::EF_COMMAND_DOWN) ==
                              ui::EF_COMMAND_DOWN));
 }
 
 void TestingAutomationProvider::WebkitMouseClick(DictionaryValue* args,
                                                  IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   WebKit::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;
@@ skipping 13 matching lines @@
     mouse_event.button = WebKit::WebMouseEvent::ButtonMiddle;
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid button press requested");
     return;
   }
 
   mouse_event.type = WebKit::WebInputEvent::MouseDown;
   mouse_event.clickCount = 1;
 
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 
   mouse_event.type = WebKit::WebInputEvent::MouseUp;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseMove(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   WebKit::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 = WebKit::WebInputEvent::MouseMove;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseDrag(DictionaryValue* args,
                                                 IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   WebKit::WebMouseEvent mouse_event;
   int start_x, start_y, end_x, end_y;
   if (!args->GetInteger("start_x", &start_x) ||
       !args->GetInteger("start_y", &start_y) ||
       !args->GetInteger("end_x", &end_x) ||
       !args->GetInteger("end_y", &end_y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid start/end positions");
     return;
   }
 
   mouse_event.type = WebKit::WebInputEvent::MouseMove;
   // Step 1- Move the mouse to the start position.
   mouse_event.x = start_x;
   mouse_event.y = start_y;
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 
   // Step 2- Left click mouse down, the mouse button is fixed.
   mouse_event.type = WebKit::WebInputEvent::MouseDown;
   mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 
   // Step 3 - Move the mouse to the end position.
-  // TODO(JMikhail): See if we should simulate the by not making such
-  // a drastic jump by placing incrmental stops along the way.
   mouse_event.type = WebKit::WebInputEvent::MouseMove;
   mouse_event.x = end_x;
   mouse_event.y = end_y;
   mouse_event.clickCount = 0;
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 
   // Step 4 - Release the left mouse button.
   mouse_event.type = WebKit::WebInputEvent::MouseUp;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseButtonDown(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   WebKit::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 = WebKit::WebInputEvent::MouseDown;
   mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseButtonUp(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   WebKit::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 = WebKit::WebInputEvent::MouseUp;
   mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseDoubleClick(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   WebKit::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 = WebKit::WebInputEvent::MouseDown;
   mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 
   mouse_event.type = WebKit::WebInputEvent::MouseUp;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         2);
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 
   mouse_event.type = WebKit::WebInputEvent::MouseDown;
   mouse_event.clickCount = 2;
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 
   mouse_event.type = WebKit::WebInputEvent::MouseUp;
-  tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
+  view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::DragAndDropFilePaths(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &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;
   }
@@ skipping 21 matching lines @@
   const gfx::Point client(x, y);
   // We don't set any values in screen variable because DragTarget*** ignore the
   // screen argument.
   const gfx::Point screen;
 
   int operations = 0;
   operations |= WebKit::WebDragOperationCopy;
   operations |= WebKit::WebDragOperationLink;
   operations |= WebKit::WebDragOperationMove;
 
-  RenderViewHost* host = tab_contents->render_view_host();
-  host->DragTargetDragEnter(
+  view->DragTargetDragEnter(
       drop_data, client, screen,
       static_cast<WebKit::WebDragOperationsMask>(operations));
   new DragTargetDropAckNotificationObserver(this, reply_message);
-  host->DragTargetDrop(client, screen);
+  view->DragTargetDrop(client, screen);
 }
 
 void TestingAutomationProvider::GetTabCount(int handle, int* tab_count) {
   *tab_count = -1;  // -1 is the error code
 
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     *tab_count = browser->tab_count();
   }
 }
@@ skipping 1040 matching lines @@
   handler_map["ExecuteJavascript"] =
       &TestingAutomationProvider::ExecuteJavascriptJSON;
   handler_map["ExecuteJavascriptInRenderView"] =
       &TestingAutomationProvider::ExecuteJavascriptInRenderView;
   handler_map["GoForward"] =
       &TestingAutomationProvider::GoForward;
   handler_map["GoBack"] =
       &TestingAutomationProvider::GoBack;
   handler_map["Reload"] =
       &TestingAutomationProvider::ReloadJSON;
-  handler_map["GetTabURL"] =
-      &TestingAutomationProvider::GetTabURLJSON;
-  handler_map["GetTabTitle"] =
-      &TestingAutomationProvider::GetTabTitleJSON;
   handler_map["CaptureEntirePage"] =
       &TestingAutomationProvider::CaptureEntirePageJSON;
   handler_map["GetCookies"] =
       &TestingAutomationProvider::GetCookiesJSON;
   handler_map["DeleteCookie"] =
       &TestingAutomationProvider::DeleteCookieJSON;
   handler_map["SetCookie"] =
       &TestingAutomationProvider::SetCookieJSON;
   handler_map["GetTabIds"] =
       &TestingAutomationProvider::GetTabIds;
+  handler_map["GetViews"] =
+      &TestingAutomationProvider::GetViews;
   handler_map["IsTabIdValid"] =
       &TestingAutomationProvider::IsTabIdValid;
+  handler_map["DoesAutomationObjectExist"] =
+      &TestingAutomationProvider::DoesAutomationObjectExist;
   handler_map["CloseTab"] =
       &TestingAutomationProvider::CloseTabJSON;
   handler_map["WebkitMouseMove"] =
       &TestingAutomationProvider::WebkitMouseMove;
   handler_map["WebkitMouseClick"] =
       &TestingAutomationProvider::WebkitMouseClick;
   handler_map["WebkitMouseDrag"] =
       &TestingAutomationProvider::WebkitMouseDrag;
   handler_map["WebkitMouseButtonUp"] =
       &TestingAutomationProvider::WebkitMouseButtonUp;
@@ skipping 28 matching lines @@
   handler_map["GetProcessInfo"] =
       &TestingAutomationProvider::GetProcessInfo;
   handler_map["SetPolicies"] =
       &TestingAutomationProvider::SetPolicies;
   handler_map["GetPolicyDefinitionList"] =
       &TestingAutomationProvider::GetPolicyDefinitionList;
   handler_map["InstallExtension"] =
       &TestingAutomationProvider::InstallExtension;
   handler_map["GetExtensionsInfo"] =
       &TestingAutomationProvider::GetExtensionsInfo;
+  handler_map["UninstallExtensionById"] =
+      &TestingAutomationProvider::UninstallExtensionById;
+  handler_map["SetExtensionStateById"] =
+      &TestingAutomationProvider::SetExtensionStateById;
   handler_map["RefreshPolicies"] =
       &TestingAutomationProvider::RefreshPolicies;
   handler_map["TriggerPageActionById"] =
       &TestingAutomationProvider::TriggerPageActionById;
   handler_map["TriggerBrowserActionById"] =
       &TestingAutomationProvider::TriggerBrowserActionById;
 #if defined(OS_CHROMEOS)
   handler_map["GetLoginInfo"] = &TestingAutomationProvider::GetLoginInfo;
   handler_map["ShowCreateAccountUI"] =
       &TestingAutomationProvider::ShowCreateAccountUI;
@@ skipping 128 matching lines @@
 
   browser_handler_map["GetBlockedPopupsInfo"] =
       &TestingAutomationProvider::GetBlockedPopupsInfo;
   browser_handler_map["UnblockAndLaunchBlockedPopup"] =
       &TestingAutomationProvider::UnblockAndLaunchBlockedPopup;
 
   // SetTheme() implemented using InstallExtension().
   browser_handler_map["GetThemeInfo"] =
       &TestingAutomationProvider::GetThemeInfo;
 
-  browser_handler_map["UninstallExtensionById"] =
-      &TestingAutomationProvider::UninstallExtensionById;
-  browser_handler_map["SetExtensionStateById"] =
-      &TestingAutomationProvider::SetExtensionStateById;
-
   browser_handler_map["FindInPage"] = &TestingAutomationProvider::FindInPage;
 
   browser_handler_map["SelectTranslateOption"] =
       &TestingAutomationProvider::SelectTranslateOption;
   browser_handler_map["GetTranslateInfo"] =
       &TestingAutomationProvider::GetTranslateInfo;
 
   browser_handler_map["GetAutofillProfile"] =
       &TestingAutomationProvider::GetAutofillProfile;
   browser_handler_map["FillAutofillProfile"] =
@@ skipping 1910 matching lines @@
     extension_value->SetString("description", extension->description());
     extension_value->SetString("background_url",
                                extension->background_url().spec());
     extension_value->SetString("options_url",
                                extension->options_url().spec());
     extension_value->Set("host_permissions",
                          GetHostPermissions(extension, false));
     extension_value->Set("effective_host_permissions",
                          GetHostPermissions(extension, true));
     extension_value->Set("api_permissions", GetAPIPermissions(extension));
+    Extension::Location location = extension->location();
     extension_value->SetBoolean("is_component",
-                                extension->location() == Extension::COMPONENT);
-    extension_value->SetBoolean("is_internal",
-                                extension->location() == Extension::INTERNAL);
+                                location == Extension::COMPONENT);
+    extension_value->SetBoolean("is_internal", location == Extension::INTERNAL);
+    extension_value->SetBoolean("is_user_installed",
+        location == Extension::INTERNAL || location == Extension::LOAD);
     extension_value->SetBoolean("is_enabled", service->IsExtensionEnabled(id));
     extension_value->SetBoolean("allowed_in_incognito",
                                 service->IsIncognitoEnabled(id));
     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(
-    Browser* browser,
     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 = profile()->GetExtensionService();
   if (!service) {
@@ skipping 13 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, id);
   service->UninstallExtension(id, false, NULL);
 }
 
 // See SetExtensionStateById() in chrome/test/pyautolib/pyauto.py
 // for sample json input.
 void TestingAutomationProvider::SetExtensionStateById(
-    Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
   std::string id;
   if (!args->GetString("id", &id)) {
-    reply.SendError("Missing or invalid key: id");
+    AutomationJSONReply(this, reply_message)
+        .SendError("Missing or invalid key: id");
     return;
   }
 
   bool enable;
   if (!args->GetBoolean("enable", &enable)) {
-    reply.SendError("Missing or invalid key: enable");
+    AutomationJSONReply(this, reply_message)
+        .SendError("Missing or invalid key: enable");
     return;
   }
 
   bool allow_in_incognito;
   if (!args->GetBoolean("allow_in_incognito", &allow_in_incognito)) {
-    reply.SendError("Missing or invalid key: allow_in_incognito");
+    AutomationJSONReply(this, reply_message)
+        .SendError("Missing or invalid key: allow_in_incognito");
     return;
   }
 
   if (allow_in_incognito && !enable) {
-    reply.SendError("Invalid state: Disabled extension "
+    AutomationJSONReply(this, reply_message)
+        .SendError("Invalid state: Disabled extension "
                     "cannot be allowed in incognito mode.");
     return;
   }
 
   ExtensionService* service = profile()->GetExtensionService();
+  ExtensionProcessManager* manager = profile()->GetExtensionProcessManager();
   if (!service) {
-    reply.SendError("No extensions service.");
+    AutomationJSONReply(this, reply_message)
+        .SendError("No extensions service or process manager.");
     return;
   }
 
   if (!service->GetExtensionById(id, true) &&
       !service->GetTerminatedExtension(id)) {
     // The extension ID does not correspond to any extension, whether crashed
     // or not.
-    reply.SendError(base::StringPrintf("Extension does not exist: %s.",
-                                       id.c_str()));
+    AutomationJSONReply(this, reply_message).SendError(
+        base::StringPrintf("Extension does not exist: %s.", id.c_str()));
     return;
   }
 
-  if (enable)
-    service->EnableExtension(id);
-  else
+  service->SetIsIncognitoEnabled(id, allow_in_incognito);
+
+  if (enable) {
+    if (!service->IsExtensionEnabled(id)) {
+      new ExtensionReadyNotificationObserver(
+          manager,
+          service,
+          this,
+          reply_message);
+      service->EnableExtension(id);
+    } else {
+      AutomationJSONReply(this, reply_message).SendSuccess(NULL);
+    }
+  } else {
     service->DisableExtension(id);
-
-  service->SetIsIncognitoEnabled(id, allow_in_incognito);
-  reply.SendSuccess(NULL);
+    AutomationJSONReply(this, reply_message).SendSuccess(NULL);
+  }
 }
 
 // See TriggerPageActionById() in chrome/test/pyautolib/pyauto.py
 // for sample json input.
 void TestingAutomationProvider::TriggerPageActionById(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
 
   std::string error;
@@ skipping 1101 matching lines @@
   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)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
-  TabContents* tab_contents;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+  RenderViewHost* view;
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   new InputEventAckNotificationObserver(this, reply_message, event.type, 1);
-  tab_contents->render_view_host()->ForwardKeyboardEvent(event);
+  view->ForwardKeyboardEvent(event);
 }
 
 void TestingAutomationProvider::SendOSLevelKeyEventToTab(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   int modifiers, keycode;
   if (!args->GetInteger("keyCode", &keycode)) {
@@ skipping 405 matching lines @@
 }
 
 void TestingAutomationProvider::ExecuteJavascriptJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   string16 frame_xpath, javascript;
   std::string error;
-  TabContents* tab_contents;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &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,
-                                     tab_contents->render_view_host());
+                                     render_view);
 }
 
 void TestingAutomationProvider::ExecuteJavascriptInRenderView(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   string16 frame_xpath, javascript, extension_id, url_text;
   std::string error;
   int render_process_id, render_view_id;
   if (!args->GetString("frame_xpath", &frame_xpath)) {
     AutomationJSONReply(this, reply_message)
@@ skipping 88 matching lines @@
   if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   NavigationController& controller = tab_contents->controller();
   new NavigationNotificationObserver(&controller, this, reply_message,
                                      1, false, true);
   controller.Reload(false);
 }
 
-void TestingAutomationProvider::GetTabURLJSON(
-    DictionaryValue* args,
-    IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-  TabContents* tab_contents;
-  std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
-    reply.SendError(error);
-    return;
-  }
-  DictionaryValue dict;
-  dict.SetString("url", tab_contents->GetURL().possibly_invalid_spec());
-  reply.SendSuccess(&dict);
-}
-
-void TestingAutomationProvider::GetTabTitleJSON(
-    DictionaryValue* args,
-    IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-  TabContents* tab_contents;
-  std::string error;
-  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
-    reply.SendError(error);
-    return;
-  }
-  DictionaryValue dict;
-  dict.SetString("title", tab_contents->GetTitle());
-  reply.SendSuccess(&dict);
-}
-
 void TestingAutomationProvider::CaptureEntirePageJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   TabContents* tab_contents;
   std::string error;
 
   if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
@@ skipping 47 matching lines @@
       int id = browser->GetTabContentsWrapperAt(i)->restore_tab_helper()->
           session_id().id();
       id_list->Append(Value::CreateIntegerValue(id));
     }
   }
   DictionaryValue dict;
   dict.Set("ids", id_list);
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
+void TestingAutomationProvider::GetViews(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  ListValue* view_list = new ListValue();
+  BrowserList::const_iterator browser_iter = BrowserList::begin();
+  for (; browser_iter != BrowserList::end(); ++browser_iter) {
+    Browser* browser = *browser_iter;
+    for (int i = 0; i < browser->tab_count(); ++i) {
+      DictionaryValue* dict = new DictionaryValue();
+      AutomationId id = automation_util::GetIdForTab(
+          browser->GetTabContentsWrapperAt(i));
+      dict->Set("auto_id", id.ToValue());
+      view_list->Append(dict);
+    }
+  }
+
+  ExtensionProcessManager* extension_mgr =
+      profile()->GetExtensionProcessManager();
+  ExtensionProcessManager::const_iterator iter;
+  for (iter = extension_mgr->begin(); iter != extension_mgr->end();
+       ++iter) {
+    ExtensionHost* host = *iter;
+    DictionaryValue* dict = new DictionaryValue();
+    AutomationId id = automation_util::GetIdForExtensionView(host);
+    if (!id.is_valid())
+      continue;
+    dict->Set("auto_id", id.ToValue());
+    dict->Set("extension_id", automation_util::GetIdForExtension(
+        host->extension()).ToValue());
+    view_list->Append(dict);
+  }
+  DictionaryValue dict;
+  dict.Set("views", view_list);
+  AutomationJSONReply(this, reply_message).SendSuccess(&dict);
+}
+
 void TestingAutomationProvider::IsTabIdValid(
     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;
   BrowserList::const_iterator iter = BrowserList::begin();
   for (; iter != BrowserList::end(); ++iter) {
     Browser* browser = *iter;
     for (int i = 0; i < browser->tab_count(); ++i) {
       TabContentsWrapper* tab = browser->GetTabContentsWrapperAt(i);
       if (tab->restore_tab_helper()->session_id().id() == id) {
         is_valid = true;
         break;
       }
     }
   }
   DictionaryValue dict;
   dict.SetBoolean("is_valid", is_valid);
   reply.SendSuccess(&dict);
 }
 
+void TestingAutomationProvider::DoesAutomationObjectExist(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  AutomationId id;
+  std::string error_msg;
+  if (!GetAutomationIdFromJSONArgs(args, "auto_id", &id, &error_msg)) {
+    reply.SendError(error_msg);
+    return;
+  }
+  DictionaryValue dict;
+  dict.SetBoolean(
+      "does_exist",
+      automation_util::DoesObjectWithIdExist(id, profile()));
+  reply.SendSuccess(&dict);
+}
+
 void TestingAutomationProvider::CloseTabJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
-  Browser* browser;
-  TabContents* tab_contents;
+  RenderViewHost* view;
   std::string error;
-  if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab_contents, &error)) {
+  if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     reply.SendError(error);
     return;
   }
-  browser->CloseTabContents(tab_contents);
+  view->ClosePage();
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::ActivateTabJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   AutomationJSONReply reply(this, reply_message);
@@ skipping 224 matching lines @@
 
   Send(reply_message_);
   redirect_query_ = 0;
   reply_message_ = NULL;
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }