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 913 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["DoesViewExist"] =
+      &TestingAutomationProvider::DoesViewExist;
   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_user_installed",

[dennis_jeffrey, 2011/12/03 00:19:37]

there's a reference to "is_internal" in pyauto.py that needs to be changed due
to the change here.

[kkania, 2011/12/03 00:34:31]

Whoops. I'm going to add both.

+        location == Extension::INTERNAL || location == Extension::LOAD);

[dennis_jeffrey, 2011/12/03 00:19:37]

if the location is Extension::INTERNAL, does that also mean it's a
user-installed extension?

[kkania, 2011/12/03 00:34:31]

INTERNAL means its from the internal extensions directory,  and not external.
LOAD means it was loaded from an unpacked extension. Currently, these are the
only two location values that are user installed.

     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("view_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("view_id", id.ToValue());
+    dict->Set("extension_id", automation_util::GetIdForExtension(
+        host->extension()).ToValue());
+    if (host->host_contents()) {
+      TabContentsWrapper* wrapper =
+          TabContentsWrapper::GetCurrentWrapperForContents(
+              host->host_contents());
+      if (wrapper)
+        dict->Set("host_id", automation_util::GetIdForTab(wrapper).ToValue());
+    }
+    view_list->Append(dict);
+  }
+  DictionaryValue dict;

[dennis_jeffrey, 2011/12/03 00:19:37]

Some other functions use this mechanism for sending return values:

scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
// fill up the dict
AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());

Is there a particular reason it's done differently here?  Is one way better than
the other?  Does it matter?

[kkania, 2011/12/03 00:34:31]

This one is better because its one less heap allocation and less verbose, but it
doesn't really matter.

+  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::DoesViewExist(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  AutomationId id;
+  std::string error_msg;
+  if (!GetAutomationIdFromJSONArgs(args, "view_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);
 }