WebDriver extension support in TestingAutomationProvider.

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 2224 matching lines @@
   dict_value = static_cast<DictionaryValue*>(values.get());
   if (!dict_value->GetStringASCII(std::string("command"), &command)) {
     AutomationJSONReply(this, reply_message)
         .SendError("no command key in dict or not a string command");
     return;
   }
 
   // Map json commands to their handlers.
   std::map<std::string, JsonHandler> handler_map;
   handler_map["WaitForAllTabsToStopLoading"] =
-      &TestingAutomationProvider::WaitForAllTabsToStopLoading;
+      &TestingAutomationProvider::WaitForAllViewsToStopLoading;
   handler_map["GetIndicesFromTab"] =
       &TestingAutomationProvider::GetIndicesFromTab;
   handler_map["NavigateToURL"] =
       &TestingAutomationProvider::NavigateToURL;
   handler_map["GetLocalStatePrefsInfo"] =
       &TestingAutomationProvider::GetLocalStatePrefsInfo;
   handler_map["SetLocalStatePrefs"] =
       &TestingAutomationProvider::SetLocalStatePrefs;
   handler_map["ExecuteJavascript"] =
       &TestingAutomationProvider::ExecuteJavascriptJSON;
@@ skipping 44 matching lines @@
   handler_map["ActivateTab"] =
       &TestingAutomationProvider::ActivateTabJSON;
   handler_map["GetAppModalDialogMessage"] =
       &TestingAutomationProvider::GetAppModalDialogMessage;
   handler_map["AcceptOrDismissAppModalDialog"] =
       &TestingAutomationProvider::AcceptOrDismissAppModalDialog;
   handler_map["GetChromeDriverAutomationVersion"] =
       &TestingAutomationProvider::GetChromeDriverAutomationVersion;
   handler_map["UpdateExtensionsNow"] =
       &TestingAutomationProvider::UpdateExtensionsNow;
+  handler_map["IsPageActionVisible"] =
+      &TestingAutomationProvider::IsPageActionVisible;
   handler_map["CreateNewAutomationProvider"] =
       &TestingAutomationProvider::CreateNewAutomationProvider;
   handler_map["GetBrowserInfo"] =
       &TestingAutomationProvider::GetBrowserInfo;
   handler_map["OpenNewBrowserWindowWithNewProfile"] =
       &TestingAutomationProvider::OpenNewBrowserWindowWithNewProfile;
   handler_map["GetMultiProfileInfo"] =
       &TestingAutomationProvider::GetMultiProfileInfo;
   handler_map["GetProcessInfo"] =
       &TestingAutomationProvider::GetProcessInfo;
@@ skipping 2089 matching lines @@
     extension_value->Set("api_permissions", GetAPIPermissions(extension));
     Extension::Location location = extension->location();
     extension_value->SetBoolean("is_component",
                                 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));
+    extension_value->SetBoolean("has_page_action",
+                                extension->page_action() != NULL);
     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,
     IPC::Message* reply_message) {
-  std::string id;
-  if (!args->GetString("id", &id)) {
-    AutomationJSONReply(this, reply_message).SendError(
-        "Must include string id.");
+  const Extension* extension;
+  std::string error;
+  if (!GetExtensionFromJSONArgs(args, "id", profile(), &extension, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   ExtensionService* service = profile()->GetExtensionService();
   if (!service) {
     AutomationJSONReply(this, reply_message).SendError(
         "No extensions service.");
     return;
   }
 
-  if (!service->GetExtensionById(id, true) &&
-      !service->GetTerminatedExtension(id)) {
-    // The extension ID does not correspond to any extension, whether crashed
-    // or not.
-    AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
-        "Extension does not exist: %s.", id.c_str()));
-    return;
-  }
-
   // 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);
+  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,
     IPC::Message* reply_message) {
-  std::string id;
-  if (!args->GetString("id", &id)) {
-    AutomationJSONReply(this, reply_message)
-        .SendError("Missing or invalid key: id");
+  const Extension* extension;
+  std::string error;
+  if (!GetExtensionFromJSONArgs(args, "id", profile(), &extension, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
   bool enable;
   if (!args->GetBoolean("enable", &enable)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Missing or invalid key: enable");
     return;
   }
 
@@ skipping 12 matching lines @@
   }
 
   ExtensionService* service = profile()->GetExtensionService();
   ExtensionProcessManager* manager = profile()->GetExtensionProcessManager();
   if (!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.
-    AutomationJSONReply(this, reply_message).SendError(
-        base::StringPrintf("Extension does not exist: %s.", id.c_str()));
-    return;
-  }
-
-  service->SetIsIncognitoEnabled(id, allow_in_incognito);
-
   if (enable) {
-    if (!service->IsExtensionEnabled(id)) {
+    if (!service->IsExtensionEnabled(extension->id())) {
       new ExtensionReadyNotificationObserver(
           manager,
           service,
           this,
           reply_message);
-      service->EnableExtension(id);
+      service->EnableExtension(extension->id());
     } else {
       AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     }
   } else {
-    service->DisableExtension(id);
+    service->DisableExtension(extension->id());
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
   }
+
+  service->SetIsIncognitoEnabled(extension->id(), allow_in_incognito);
 }
 
+namespace {
+
+// Selects the given |browser| and |tab| if not selected already.
+void EnsureTabSelected(Browser* browser, TabContents* tab) {
+  TabContentsWrapper* active =
+      browser->tabstrip_model()->GetActiveTabContents();
+  if (!active || active->tab_contents() != tab ||
+      browser != BrowserList::GetLastActive()) {
+    browser->ActivateTabAt(
+        browser->tabstrip_model()->GetIndexOfController(&tab->controller()),
+        true /* user_gesture */);
+  }
+}
+
+}  // namespace
+
 // 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;
   Browser* browser;
-  if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
-    reply.SendError(error);
+  TabContents* tab;
+  if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
-  std::string id;
-  if (!args->GetString("id", &id)) {
-    reply.SendError("Missing or invalid key: id");
+  const Extension* extension;
+  if (!GetEnabledExtensionFromJSONArgs(
+          args, "id", profile(), &extension, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+  ExtensionAction* page_action = extension->page_action();
+  if (!page_action) {
+    AutomationJSONReply(this, reply_message).SendError(
+        "Extension doesn't have any page action.");
+    return;
+  }
+  EnsureTabSelected(browser, tab);
+
+  bool pressed = false;
+  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) {
+      loc_bar->TestPageActionPressed(i);
+      pressed = true;
+      break;
+    }
+  }
+  if (!pressed) {
+    AutomationJSONReply(this, reply_message).SendError(
+        "Extension's page action is not visible.");
     return;
   }
 
-  ExtensionService* service = browser->profile()->GetExtensionService();
-  if (!service) {
-    reply.SendError("No extensions service.");
-    return;
-  }
-  if (!service->GetInstalledExtension(id)) {
-    // The extension ID does not correspond to any extension, whether crashed
-    // or not.
-    reply.SendError(base::StringPrintf("Extension %s is not installed.",
-                                       id.c_str()));
-    return;
-  }
-  const Extension* extension = service->GetExtensionById(id, false);
-  if (!extension) {
-    reply.SendError("Extension is disabled or has crashed.");
-    return;
-  }
-
-  if (ExtensionAction* page_action = extension->page_action()) {
-    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) {
-        loc_bar->TestPageActionPressed(i);
-        reply.SendSuccess(NULL);
-        return;
-      }
-    }
-    reply.SendError("Extension doesn't have any visible page action icon.");
+  if (page_action->HasPopup(ExtensionTabUtil::GetTabId(tab))) {
+    // This observer will delete itself.
+    new ExtensionPopupObserver(
+        this, reply_message, extension->id());
   } else {
-    reply.SendError("Extension doesn't have any page action.");
+    AutomationJSONReply(this, reply_message).SendSuccess(NULL);
   }
 }
 
 // See TriggerBrowserActionById() in chrome/test/pyautolib/pyauto.py
 // for sample json input.
 void TestingAutomationProvider::TriggerBrowserActionById(
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
-
   std::string error;
   Browser* browser;
-  if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
-    reply.SendError(error);
+  TabContents* tab;
+  if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
-  std::string id;
-  if (!args->GetString("id", &id)) {
-    reply.SendError("Missing or invalid key: id");
+  const Extension* extension;
+  if (!GetEnabledExtensionFromJSONArgs(
+          args, "id", profile(), &extension, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
-
-  ExtensionService* service = browser->profile()->GetExtensionService();
-  if (!service) {
-    reply.SendError("No extensions service.");
+  ExtensionAction* action = extension->browser_action();
+  if (!action) {
+    AutomationJSONReply(this, reply_message).SendError(
+        "Extension doesn't have any browser action.");
     return;
   }
-  if (!service->GetInstalledExtension(id)) {
-    // The extension ID does not correspond to any extension, whether crashed
-    // or not.
-    reply.SendError(base::StringPrintf("Extension %s is not installed.",
-                                       id.c_str()));
+  EnsureTabSelected(browser, tab);
+
+  BrowserActionTestUtil browser_actions(browser);
+  int num_browser_actions = browser_actions.NumberOfBrowserActions();
+  int action_index = -1;
+#if defined(TOOLKIT_VIEWS)
+  for (int i = 0; i < num_browser_actions; ++i) {
+    if (extension->id() == browser_actions.GetExtensionId(i)) {
+      action_index = i;
+      break;
+    }
+  }
+#else
+  // TODO(kkania): Implement the platform-specific GetExtensionId() in
+  // BrowserActionTestUtil.
+  if (num_browser_actions != 1) {
+    AutomationJSONReply(this, reply_message).SendError(StringPrintf(
+        "Found %d browser actions. Only one browser action must be active.",
+        num_browser_actions));
     return;
   }
-  const Extension* extension = service->GetExtensionById(id, false);
-  if (!extension) {
-    reply.SendError("Extension is disabled or has crashed.");
+  // This extension has a browser action, and there's only one action, so this
+  // must be the first one.
+  action_index = 0;
+#endif
+  if (action_index == -1) {
+    AutomationJSONReply(this, reply_message).SendError(
+        "Extension's browser action is not visible.");
     return;
   }
+  browser_actions.Press(action_index);
 
-  if (extension->browser_action()) {
-    BrowserActionTestUtil browser_actions(browser);
-    int num_browser_actions = browser_actions.NumberOfBrowserActions();
-    // TODO: Implement the platform-specific GetExtensionId() in
-    // BrowserActionTestUtil.
-    if (num_browser_actions != 1) {
-      reply.SendError(StringPrintf(
-          "Found %d browser actions. Only one browser action must be active.",
-          num_browser_actions));
-      return;
-    }
-    browser_actions.Press(0);
-    reply.SendSuccess(NULL);
-    return;
+  if (action->HasPopup(ExtensionTabUtil::GetTabId(tab))) {
+    // This observer will delete itself.
+    new ExtensionPopupObserver(
+        this, reply_message, extension->id());
   } else {
-    reply.SendError("Extension doesn't have any browser action.");
-    return;
+    AutomationJSONReply(this, reply_message).SendSuccess(NULL);
   }
 }
 
 // Sample json input:
 //    { "command": "GetAutofillProfile" }
 // Refer to GetAutofillProfile() in chrome/test/pyautolib/pyauto.py for sample
 // json output.
 void TestingAutomationProvider::GetAutofillProfile(
     Browser* browser,
     DictionaryValue* args,
@@ skipping 1224 matching lines @@
   } else {
     reply.SendError(
         StringPrintf("Unexpected launch type '%s'.", launch_type_str.c_str()));
     return;
   }
 
   service->extension_prefs()->SetLaunchType(extension->id(), launch_type);
   reply.SendSuccess(NULL);
 }
 
-void TestingAutomationProvider::WaitForAllTabsToStopLoading(
+void TestingAutomationProvider::WaitForAllViewsToStopLoading(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (AppModalDialogQueue::GetInstance()->HasActiveDialog()) {
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     return;
   }
 
   // This class will send the message immediately if no tab is loading.
-  new AllTabsStoppedLoadingObserver(this, reply_message);
+  new AllViewsStoppedLoadingObserver(
+      this, reply_message, profile()->GetExtensionProcessManager());
 }
 
 void TestingAutomationProvider::SetPolicies(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   scoped_ptr<AutomationJSONReply> reply(
       new AutomationJSONReply(this, reply_message));
 
 #if !defined(ENABLE_CONFIGURATION_POLICY) || defined(OFFICIAL_BUILD)
   reply->SendError("Configuration Policy disabled");
@@ skipping 388 matching lines @@
       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());
+    dict->SetString("extension_id", host->extension_id());
     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);
@@ skipping 93 matching lines @@
     return;
   }
 
   // Create a new observer that waits until the extensions have been fully
   // updated (we should not send the reply until after all extensions have
   // been updated).  This observer will delete itself.
   new ExtensionsUpdatedObserver(manager, this, reply_message);
   updater->CheckNow();
 }
 
+void TestingAutomationProvider::IsPageActionVisible(
+    base::DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+
+  TabContents* tab;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  const Extension* extension;
+  if (!GetEnabledExtensionFromJSONArgs(
+          args, "extension_id", profile(), &extension, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  ExtensionAction* page_action = extension->page_action();
+  if (!page_action) {
+    reply.SendError("Extension doesn't have any page action");
+    return;
+  }
+  Browser* browser = automation_util::GetBrowserForTab(tab);
+  if (!browser) {
+    reply.SendError("Tab does not belong to an open browser");
+    return;
+  }
+  EnsureTabSelected(browser, tab);
+
+  bool is_visible = false;
+  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;
+  dict.SetBoolean("is_visible", is_visible);
+  reply.SendSuccess(&dict);
+}
+
 void TestingAutomationProvider::GetChromeDriverAutomationVersion(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   DictionaryValue reply_dict;
   reply_dict.SetInteger("version", automation::kChromeDriverAutomationVersion);
   AutomationJSONReply(this, reply_message).SendSuccess(&reply_dict);
 }
 
 void TestingAutomationProvider::CreateNewAutomationProvider(
     DictionaryValue* args,
@@ skipping 169 matching lines @@
 
   Send(reply_message_);
   redirect_query_ = 0;
   reply_message_ = NULL;
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }