Add commands to Chrome WebDriver for installing and manipulating extensions.

chrome/test/webdriver/webdriver_session.h

 // 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.
 
 #ifndef CHROME_TEST_WEBDRIVER_WEBDRIVER_SESSION_H_
 #define CHROME_TEST_WEBDRIVER_WEBDRIVER_SESSION_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/threading/thread.h"
 #include "chrome/common/automation_constants.h"
+#include "chrome/test/automation/automation_json_requests.h"
 #include "chrome/test/webdriver/frame_path.h"
 #include "chrome/test/webdriver/webdriver_automation.h"
 #include "chrome/test/webdriver/webdriver_basic_types.h"
 #include "chrome/test/webdriver/webdriver_element_id.h"
 
 class FilePath;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 class Value;
 class WaitableEvent;
 }
 
 namespace webdriver {
 
 class Error;
 class ValueParser;
 
-// A window ID and frame path combination that uniquely identifies a specific
+// A view ID and frame path combination that uniquely identifies a specific
 // frame within a session.
 struct FrameId {
-  FrameId(int window_id, const FramePath& frame_path);
-  FrameId& operator=(const FrameId& other);
-  int window_id;
+  FrameId();
+  FrameId(const WebViewId& view_id, const FramePath& frame_path);
+
+  WebViewId view_id;
   FramePath frame_path;
 };
 
 // Every connection made by WebDriver maps to a session object.
 // This object creates the chrome instance and keeps track of the
 // state necessary to control the chrome browser created.
 // A session manages its own lifetime.
 class Session {
  public:
   struct Options {
@@ skipping 90 matching lines @@
   Error* GoForward();
   Error* GoBack();
   Error* Reload();
   Error* GetURL(std::string* url);
   Error* GetTitle(std::string* tab_title);
   Error* GetScreenShot(std::string* png);
   Error* GetCookies(const std::string& url, base::ListValue** cookies);
   Error* DeleteCookie(const std::string& url, const std::string& cookie_name);
   Error* SetCookie(const std::string& url, base::DictionaryValue* cookie_dict);
 
-  // Gets all the currently existing window IDs. Returns true on success.
-  Error* GetWindowIds(std::vector<int>* window_ids);
+  // Gets all the currently open views.
+  Error* GetViews(std::vector<WebViewInfo>* views);
 
-  // Switches the window used by default. |name| is either an ID returned by
-  // |GetWindowIds| or the name attribute of a DOM window.
-  Error* SwitchToWindow(const std::string& name);
+  // Switches the view used by default. |id_or_name| is either a view ID
+  // returned by |GetViews| or the name attribute of a DOM window.
+  // Only tabs are considered when searching by name.
+  Error* SwitchToView(const std::string& id_or_name);
 
   // Switches the frame used by default. |name_or_id| is either the name or id
   // of a frame element.
   Error* SwitchToFrameWithNameOrId(const std::string& name_or_id);
 
   // Switches the frame used by default. |index| is the zero-based frame index.
   Error* SwitchToFrameWithIndex(int index);
 
   // Switches to the frame identified by the given |element|. The element must
   // be either an IFRAME or FRAME element.
@@ skipping 128 matching lines @@
   // location of the element. If the element is not clickable, or if the
   // location cannot be determined, an error will be returned.
   Error* GetClickableLocation(const ElementId& element,
                               Point* location);
 
   // Gets the attribute of the given element. If there are no errors, the
   // function sets |value| and the caller takes ownership.
   Error* GetAttribute(const ElementId& element, const std::string& key,
                       base::Value** value);
 
-  // Waits for all tabs to stop loading. Returns true on success.
-  Error* WaitForAllTabsToStopLoading();
+  // Waits for all views to stop loading. Returns true on success.
+  Error* WaitForAllViewsToStopLoading();
 
   // Install packed extension at |path|.
   Error* InstallExtensionDeprecated(const FilePath& path);
 
-  // Get installed extensions IDs.
-  Error* GetInstalledExtensions(std::vector<std::string>* extension_ids);
-
   // Install extension at |path|.
   Error* InstallExtension(const FilePath& path, std::string* extension_id);
 
+  Error* GetExtensionsInfo(base::ListValue* extension_ids);
+
+  Error* IsPageActionVisible(const WebViewId& tab_id,
+                             const std::string& extension_id,
+                             bool* is_visible);
+
+  Error* SetExtensionState(const std::string& extension_id,
+                           bool enable);
+
+  Error* ClickExtensionButton(const std::string& extension_id,
+                              bool browser_action);
+
+  Error* UninstallExtension(const std::string& extension_id);
+
   const std::string& id() const;
 
   const FrameId& current_target() const;
 
   void set_async_script_timeout(int timeout_ms);
   int async_script_timeout() const;
 
   void set_implicit_wait(int timeout_ms);
   int implicit_wait() const;
 
@@ skipping 87 matching lines @@
   Options options_;
 
   DISALLOW_COPY_AND_ASSIGN(Session);
 };
 
 }  // namespace webdriver
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(webdriver::Session);
 
 #endif  // CHROME_TEST_WEBDRIVER_WEBDRIVER_SESSION_H_