Allow chromedriver to install an extension and get all installed extension IDs.

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;
+  view_id = other.view_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 192 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.id.tab_id,  // FIXME
       location,
       paths,
       &error));
   return error;
 }
 
 Error* Session::NavigateToURL(const std::string& url) {
   Error* error = NULL;
   if (options_.load_async) {
     RunSessionTask(NewRunnableMethod(
         automation_.get(),
         &Automation::NavigateToURLAsync,
-        current_target_.window_id,
+        current_target_.view_id.id.tab_id,  // FIXME
         url,
         &error));
   } else {
     RunSessionTask(NewRunnableMethod(
         automation_.get(),
         &Automation::NavigateToURL,
-        current_target_.window_id,
+        current_target_.view_id.id.tab_id,  // FIXME
         url,
         &error));
   }
   return error;
 }
 
 Error* Session::GoForward() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GoForward,
-      current_target_.window_id,
+      current_target_.view_id.id.tab_id,  // FIXME
       &error));
   return error;
 }
 
 Error* Session::GoBack() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GoBack,
-      current_target_.window_id,
+      current_target_.view_id.id.tab_id,  // FIXME
       &error));
   return error;
 }
 
 Error* Session::Reload() {
   Error* error = NULL;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::Reload,
-      current_target_.window_id,
+      current_target_.view_id.id.tab_id,  // FIXME
       &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.id.tab_id,  // FIXME
       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.id.tab_id,  // FIXME
       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.id.tab_id,  // FIXME
       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.id.tab_id,  // FIXME
       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.id.tab_id,  // FIXME
       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.id.tab_id,  // FIXME
       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;
+
+  bool new_version = false;
+  error = CompareBrowserVersion(500, 0, &new_version);
+  if (error)
+    return error;
+  int id_no;
+  WebViewId new_view;
+  if (new_version) {
+    std::vector<std::string> parts;
+    // Check if valid type.
+    base::SplitString(id_or_name, '|', &parts);
+    int type;
+    if (parts.size() == 2 && base::StringToInt(parts[0], &type)) {
+      new_view = WebViewId::ForView(
+          AutomationId(static_cast<AutomationId::Type>(type),
+                       parts[1]));
+    }
+  } else if (base::StringToInt(id_or_name, &id_no)) {
+    new_view = WebViewId::ForTab(id_no);
+  }
+  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.type != WebViewId::kTypeTabId)
+        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,
+      current_target_.view_id.id.tab_id,  // FIXME
       &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 303 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.id.tab_id,  // FIXME
           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.id.tab_id,  // FIXME
+          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 235 matching lines @@
   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.id.tab_id,  // FIXME
       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