Add commands to Chrome WebDriver for installing and manipulating extensions.

chrome/test/webdriver/webdriver_session.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/test/webdriver/webdriver_session.h"
 
 #include <sstream>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 #include "chrome/test/automation/automation_json_requests.h"
 #include "chrome/test/automation/value_conversion_util.h"
 #include "chrome/test/webdriver/webdriver_error.h"
 #include "chrome/test/webdriver/webdriver_key_converter.h"
 #include "chrome/test/webdriver/webdriver_session_manager.h"
 #include "chrome/test/webdriver/webdriver_util.h"
 #include "third_party/webdriver/atoms.h"
 
 namespace webdriver {
 
-FrameId::FrameId(int window_id, const FramePath& frame_path)
-    : window_id(window_id),
+FrameId::FrameId() {}
+
+FrameId::FrameId(const WebViewId& view_id, const FramePath& frame_path)
+    : view_id(view_id),
       frame_path(frame_path) {
 }
 
-FrameId& FrameId::operator=(const FrameId& other) {
-  window_id = other.window_id;
-  frame_path = other.frame_path;
-  return *this;
-}
-
 Session::Options::Options()
     : use_native_events(false),
       load_async(false) {
 }
 
 Session::Options::~Options() {
 }
 
 Session::Session(const Options& options)
     : id_(GenerateRandomID()),
-      current_target_(FrameId(0, FramePath())),
+      current_target_(FrameId(WebViewId(), FramePath())),
       thread_(id_.c_str()),
       async_script_timeout_(0),
       implicit_wait_(0),
       has_alert_prompt_text_(false),
       options_(options) {
   SessionManager::GetInstance()->Add(this);
 }
 
 Session::~Session() {
   SessionManager::GetInstance()->Remove(id_);
@@ skipping 30 matching lines @@
       }
     }
   }
   return error;
 }
 
 Error* Session::AfterExecuteCommand() {
   Error* error = NULL;
   if (!options_.load_async) {
     LOG(INFO) << "Waiting for the page to stop loading";
-    error = WaitForAllTabsToStopLoading();
+    error = WaitForAllViewsToStopLoading();
     LOG(INFO) << "Done waiting for the page to stop loading";
   }
   return error;
 }
 
 void Session::Terminate() {
   RunSessionTask(NewRunnableMethod(
       this,
       &Session::TerminateOnSessionThread));
   delete this;
@@ skipping 141 matching lines @@
   return error;
 }
 
 Error* Session::DragAndDropFilePaths(
     const Point& location,
     const std::vector<FilePath::StringType>& paths) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::DragAndDropFilePaths,
-      current_target_.window_id,
+      current_target_.view_id,
       location,
       paths,
       &error));
   return error;
 }
 
 Error* Session::NavigateToURL(const std::string& url) {
+  if (!current_target_.view_id.IsTab()) {
+    return new Error(kUnknownError,
+                     "The current target does not support navigation");
+  }
   Error* error = NULL;
   if (options_.load_async) {
     RunSessionTask(NewRunnableMethod(
         automation_.get(),
         &Automation::NavigateToURLAsync,
-        current_target_.window_id,
+        current_target_.view_id,
         url,
         &error));
   } else {
     RunSessionTask(NewRunnableMethod(
         automation_.get(),
         &Automation::NavigateToURL,
-        current_target_.window_id,
+        current_target_.view_id,
         url,
         &error));
   }
   return error;
 }
 
 Error* Session::GoForward() {
+  if (!current_target_.view_id.IsTab()) {
+    return new Error(kUnknownError,
+                     "The current target does not support navigation");
+  }
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GoForward,
-      current_target_.window_id,
+      current_target_.view_id,
       &error));
   return error;
 }
 
 Error* Session::GoBack() {
+  if (!current_target_.view_id.IsTab()) {
+    return new Error(kUnknownError,
+                     "The current target does not support navigation");
+  }
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GoBack,
-      current_target_.window_id,
+      current_target_.view_id,
       &error));
   return error;
 }
 
 Error* Session::Reload() {
+  if (!current_target_.view_id.IsTab()) {
+    return new Error(kUnknownError,
+                     "The current target does not support navigation");
+  }
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::Reload,
-      current_target_.window_id,
+      current_target_.view_id,
       &error));
   return error;
 }
 
 Error* Session::GetURL(std::string* url) {
   return ExecuteScriptAndParse(current_target_,
                                "function() { return document.URL }",
                                "getUrl",
                                new ListValue(),
                                CreateDirectValueParser(url));
 }
 
 Error* Session::GetTitle(std::string* tab_title) {
   const char* kGetTitleScript =
       "function() {"
       "  if (document.title)"
       "    return document.title;"
       "  else"
       "    return document.URL;"
       "}";
-  return ExecuteScriptAndParse(FrameId(current_target_.window_id, FramePath()),
+  return ExecuteScriptAndParse(FrameId(current_target_.view_id, FramePath()),
                                kGetTitleScript,
                                "getTitle",
                                new ListValue(),
                                CreateDirectValueParser(tab_title));
 }
 
 Error* Session::MouseMoveAndClick(const Point& location,
                                   automation::MouseButton button) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseClick,
-      current_target_.window_id,
+      current_target_.view_id,
       location,
       button,
       &error));
   if (!error)
     mouse_position_ = location;
   return error;
 }
 
 Error* Session::MouseMove(const Point& location) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseMove,
-      current_target_.window_id,
+      current_target_.view_id,
       location,
       &error));
   if (!error)
     mouse_position_ = location;
   return error;
 }
 
 Error* Session::MouseDrag(const Point& start,
                           const Point& end) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseDrag,
-      current_target_.window_id,
+      current_target_.view_id,
       start,
       end,
       &error));
   if (!error)
     mouse_position_ = end;
   return error;
 }
 
 Error* Session::MouseClick(automation::MouseButton button) {
   return MouseMoveAndClick(mouse_position_, button);
 }
 
 Error* Session::MouseButtonDown() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseButtonDown,
-      current_target_.window_id,
+      current_target_.view_id,
       mouse_position_,
       &error));
   return error;
 }
 
 Error* Session::MouseButtonUp() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseButtonUp,
-      current_target_.window_id,
+      current_target_.view_id,
       mouse_position_,
       &error));
   return error;
 }
 
 Error* Session::MouseDoubleClick() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseDoubleClick,
-      current_target_.window_id,
+      current_target_.view_id,
       mouse_position_,
       &error));
   return error;
 }
 
 Error* Session::GetCookies(const std::string& url, ListValue** cookies) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GetCookies,
@@ skipping 20 matching lines @@
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::SetCookie,
       url,
       cookie_dict,
       &error));
   return error;
 }
 
-Error* Session::GetWindowIds(std::vector<int>* window_ids) {
+Error* Session::GetViews(std::vector<WebViewInfo>* views) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
-      &Automation::GetTabIds,
-      window_ids,
+      &Automation::GetViews,
+      views,
       &error));
   return error;
 }
 
-Error* Session::SwitchToWindow(const std::string& name) {
-  int switch_to_id = 0;
-  int name_no = 0;
-  if (base::StringToInt(name, &name_no)) {
-    Error* error = NULL;
-    bool does_exist = false;
+Error* Session::SwitchToView(const std::string& id_or_name) {
+  Error* error = NULL;
+  bool does_exist = false;
+
+  WebViewId new_view;
+  StringToWebViewId(id_or_name, &new_view);
+  if (new_view.IsValid()) {
     RunSessionTask(NewRunnableMethod(
         automation_.get(),
-        &Automation::DoesTabExist,
-        name_no,
+        &Automation::DoesViewExist,
+        new_view,
         &does_exist,
         &error));
     if (error)
       return error;
-    if (does_exist)
-      switch_to_id = name_no;
   }
 
-  if (!switch_to_id) {
-    std::vector<int> window_ids;
-    Error* error = GetWindowIds(&window_ids);
+  if (!does_exist) {
+    // See if any of the tab window names match |name|.
+    std::vector<WebViewInfo> views;
+    Error* error = GetViews(&views);
     if (error)
       return error;
-    // See if any of the window names match |name|.
-    for (size_t i = 0; i < window_ids.size(); ++i) {
+    for (size_t i = 0; i < views.size(); ++i) {
+      if (!views[i].view_id.IsTab())
+        continue;
       std::string window_name;
       Error* error = ExecuteScriptAndParse(
-          FrameId(window_ids[i], FramePath()),
+          FrameId(views[i].view_id, FramePath()),
           "function() { return window.name; }",
           "getWindowName",
           new ListValue(),
           CreateDirectValueParser(&window_name));
       if (error)
         return error;
-      if (name == window_name) {
-        switch_to_id = window_ids[i];
+      if (id_or_name == window_name) {
+        new_view = views[i].view_id;
+        does_exist = true;
         break;
       }
     }
   }
 
-  if (!switch_to_id)
+  if (!does_exist)
     return new Error(kNoSuchWindow);
   frame_elements_.clear();
-  current_target_ = FrameId(switch_to_id, FramePath());
+  current_target_ = FrameId(new_view, FramePath());
   return NULL;
 }
 
 Error* Session::SwitchToFrameWithNameOrId(const std::string& name_or_id) {
   std::string script =
       "function(arg) {"
       "  var xpath = '(/html/body//iframe|/html/frameset/frame)';"
       "  var sub = function(s) { return s.replace(/\\$/g, arg); };"
       "  xpath += sub('[@name=\"$\" or @id=\"$\"]');"
       "  var frame = document.evaluate(xpath, document, null, "
@@ skipping 64 matching lines @@
   if (frame_elements_.size() != components.size()) {
     return new Error(kUnknownError,
                      "Frame element vector out of sync with frame path");
   }
   FramePath frame_path;
   // Start from the root path and check that each frame element that makes
   // up the current frame target is valid by executing an empty script.
   // This code should not execute script in any frame before making sure the
   // frame element is valid, otherwise the automation hangs until a timeout.
   for (size_t i = 0; i < frame_elements_.size(); ++i) {
-    FrameId frame_id(current_target_.window_id, frame_path);
+    FrameId frame_id(current_target_.view_id, frame_path);
     scoped_ptr<Error> error(ExecuteScriptAndParse(
         frame_id,
         "function(){ }",
         "emptyScript",
         CreateListValueFrom(frame_elements_[i]),
         CreateDirectValueParser(kSkipParsing)));
     if (error.get() && error->code() == kStaleElementReference) {
       SwitchToTopFrame();
     } else if (error.get()) {
       return error.release();
     }
     frame_path = frame_path.Append(components[i]);
   }
   return NULL;
 }
 
 Error* Session::CloseWindow() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
-      &Automation::CloseTab,
-      current_target_.window_id,
+      &Automation::CloseView,
+      current_target_.view_id,
       &error));
 
   if (!error) {
-    std::vector<int> window_ids;
-    scoped_ptr<Error> error(GetWindowIds(&window_ids));
-    if (error.get() || window_ids.empty()) {
+    std::vector<WebViewInfo> views;
+    scoped_ptr<Error> error(GetViews(&views));
+    if (error.get() || views.empty()) {
       // The automation connection will soon be closed, if not already,
       // because we supposedly just closed the last window. Terminate the
       // session.
       // TODO(kkania): This will cause us problems if GetWindowIds fails for a
       // reason other than the channel is disconnected. Look into having
       // |GetWindowIds| tell us if it just closed the last window.
       Terminate();
     }
   }
   return error;
@@ skipping 120 matching lines @@
   Error* error = GetElementRegionInViewHelper(
       current_target_, element, region, center, verify_clickable_at_middle,
       &region_offset);
   if (error)
     return error;
 
   for (FramePath frame_path = current_target_.frame_path;
        frame_path.IsSubframe();
        frame_path = frame_path.Parent()) {
     // Find the frame element for the current frame path.
-    FrameId frame_id(current_target_.window_id, frame_path.Parent());
+    FrameId frame_id(current_target_.view_id, frame_path.Parent());
     ElementId frame_element;
     error = FindElement(
         frame_id, ElementId(""),
         LocatorType::kXpath, frame_path.BaseName().value(), &frame_element);
     if (error) {
       std::string context = base::StringPrintf(
           "Could not find frame element (%s) in frame (%s)",
           frame_path.BaseName().value().c_str(),
           frame_path.Parent().value().c_str());
       error->AddDetails(context);
@@ skipping 187 matching lines @@
                              const std::string& key,
                              Value** value) {
   return ExecuteScriptAndParse(
       current_target_,
       atoms::asString(atoms::GET_ATTRIBUTE),
       "getAttribute",
       CreateListValueFrom(element, key),
       CreateDirectValueParser(value));
 }
 
-Error* Session::WaitForAllTabsToStopLoading() {
+Error* Session::WaitForAllViewsToStopLoading() {
   if (!automation_.get())
     return NULL;
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
-      &Automation::WaitForAllTabsToStopLoading,
+      &Automation::WaitForAllViewsToStopLoading,
       &error));
   return error;
 }
 
 Error* Session::InstallExtensionDeprecated(const FilePath& path) {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::InstallExtensionDeprecated,
       path,
       &error));
   return error;
 }
 
-Error* Session::GetInstalledExtensions(
-    std::vector<std::string>* extension_ids) {
-  Error* error = NULL;
-  RunSessionTask(base::Bind(
-      &Automation::GetInstalledExtensions,
-      base::Unretained(automation_.get()),
-      extension_ids,
-      &error));
-  return error;
-}
-
 Error* Session::InstallExtension(
     const FilePath& path, std::string* extension_id) {
   Error* error = NULL;
   RunSessionTask(base::Bind(
       &Automation::InstallExtension,
       base::Unretained(automation_.get()),
       path,
       extension_id,
       &error));
   return error;
+}
+
+Error* Session::GetExtensionsInfo(base::ListValue* extensions_list) {
+  Error* error = NULL;
+  RunSessionTask(base::Bind(
+      &Automation::GetExtensionsInfo,
+      base::Unretained(automation_.get()),
+      extensions_list,
+      &error));
+  return error;
+}
+
+Error* Session::IsPageActionVisible(
+    const WebViewId& tab_id,
+    const std::string& extension_id,
+    bool* is_visible) {
+  if (!tab_id.IsTab()) {
+    return new Error(
+        kUnknownError,
+        "The current target does not support page actions. Switch to a tab.");
+  }
+  Error* error = NULL;
+  RunSessionTask(base::Bind(
+      &Automation::IsPageActionVisible,
+      base::Unretained(automation_.get()),
+      tab_id,
+      extension_id,
+      is_visible,
+      &error));
+  return error;
+}
+
+Error* Session::SetExtensionState(
+    const std::string& extension_id, bool enable) {
+  Error* error = NULL;
+  RunSessionTask(base::Bind(
+      &Automation::SetExtensionState,
+      base::Unretained(automation_.get()),
+      extension_id,
+      enable,
+      &error));
+  return error;
+}
+
+Error* Session::ClickExtensionButton(
+    const std::string& extension_id, bool browser_action) {
+  Error* error = NULL;
+  RunSessionTask(base::Bind(
+      &Automation::ClickExtensionButton,
+      base::Unretained(automation_.get()),
+      extension_id,
+      browser_action,
+      &error));
+  return error;
+}
+
+Error* Session::UninstallExtension(const std::string& extension_id) {
+  Error* error = NULL;
+  RunSessionTask(base::Bind(
+      &Automation::UninstallExtension,
+      base::Unretained(automation_.get()),
+      extension_id,
+      &error));
+  return error;
 }
 
 const std::string& Session::id() const {
   return id_;
 }
 
 const FrameId& Session::current_target() const {
   return current_target_;
 }
 
@@ skipping 54 matching lines @@
   done_event->Signal();
 }
 
 void Session::InitOnSessionThread(const Automation::BrowserOptions& options,
                                   Error** error) {
   automation_.reset(new Automation());
   automation_->Init(options, error);
   if (*error)
     return;
 
-  std::vector<int> tab_ids;
-  automation_->GetTabIds(&tab_ids, error);
+  std::vector<WebViewInfo> views;
+  automation_->GetViews(&views, error);
   if (*error)
     return;
-  if (tab_ids.empty()) {
-    *error = new Error(kUnknownError, "No tab ids after initialization");
+  if (views.empty()) {
+    *error = new Error(kUnknownError, "No view ids after initialization");
     return;
   }
-  current_target_ = FrameId(tab_ids[0], FramePath());
+  current_target_ = FrameId(views[0].view_id, FramePath());
 }
 
 void Session::TerminateOnSessionThread() {
   if (automation_.get())
     automation_->Terminate();
   automation_.reset();
 }
 
 Error* Session::ExecuteScriptAndParseValue(const FrameId& frame_id,
                                            const std::string& script,
                                            Value** script_result) {
   std::string response_json;
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::ExecuteScript,
-      frame_id.window_id,
+      frame_id.view_id,
       frame_id.frame_path,
       script,
       &response_json,
       &error));
   if (error)
     return error;
 
   scoped_ptr<Value> value(base::JSONReader::ReadAndReturnError(
       response_json, true, NULL, NULL));
   if (!value.get())
@@ skipping 36 matching lines @@
     return;
   }
   for (size_t i = 0; i < key_events.size(); ++i) {
     if (options_.use_native_events) {
       // The automation provider will generate up/down events for us, we
       // only need to call it once as compared to the WebKeyEvent method.
       // Hence we filter events by their types, keeping only rawkeydown.
       if (key_events[i].type != automation::kRawKeyDownType)
         continue;
       automation_->SendNativeKeyEvent(
-          current_target_.window_id,
+          current_target_.view_id,
           key_events[i].key_code,
           key_events[i].modifiers,
           error);
     } else {
       automation_->SendWebKeyEvent(
-          current_target_.window_id, key_events[i], error);
+          current_target_.view_id,
+          key_events[i], error);
     }
     if (*error) {
       std::string details = base::StringPrintf(
           "Failed to send key event. Event details:\n"
               "Type: %d, KeyCode: %d, UnmodifiedText: %s, ModifiedText: %s, "
               "Modifiers: %d",
           key_events[i].type,
           key_events[i].key_code,
           key_events[i].unmodified_text.c_str(),
           key_events[i].modified_text.c_str(),
@@ skipping 224 matching lines @@
     middle_point.Offset(region.width() / 2, region.height() / 2);
     error = VerifyElementIsClickable(frame_id, element, middle_point);
     if (error)
       return error;
   }
   *location = temp_location;
   return NULL;
 }
 
 Error* Session::GetScreenShot(std::string* png) {
+  if (!current_target_.view_id.IsTab()) {
+    return new Error(kUnknownError,
+                     "The current target does not support screenshot");
+  }
   Error* error = NULL;
   ScopedTempDir screenshots_dir;
   if (!screenshots_dir.CreateUniqueTempDir()) {
     return new Error(kUnknownError,
                      "Could not create temp directory for screenshot");
   }
 
   FilePath path = screenshots_dir.path().AppendASCII("screen");
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::CaptureEntirePageAsPNG,
-      current_target_.window_id,
+      current_target_.view_id,
       path,
       &error));
   if (error)
     return error;
   if (!file_util::ReadFileToString(path, png))
     return new Error(kUnknownError, "Could not read screenshot file");
   return NULL;
 }
 
 Error* Session::GetBrowserConnectionState(bool* online) {
   return ExecuteScriptAndParse(
       current_target_,
       atoms::asString(atoms::IS_ONLINE),
       "isOnline",
       new ListValue(),
       CreateDirectValueParser(online));
 }
 
 Error* Session::GetAppCacheStatus(int* status) {
   return ExecuteScriptAndParse(
       current_target_,
       atoms::asString(atoms::GET_APPCACHE_STATUS),
       "getAppcacheStatus",
       new ListValue(),
       CreateDirectValueParser(status));
 }
 
 }  // namespace webdriver