[ChromeDriver] Support window resizing commands with remote connection

Add support with remote connection for methods:
SetWindowRect(), SetWindowPosition(), MaximizeWindow(),
MinimizeWindow() and FullScreenWindow()

Bug: chromedriver:1855
Change-Id: I452cd54d2fea79763f87a30edb1d034851ed0eea
Reviewed-on: https://chromium-review.googlesource.com/c/1263567
Commit-Queue: Tatiana Buldina <buldina@chromium.org>
Reviewed-by: John Chen <johnchen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#597177}

chrome/test/chromedriver/chrome/chrome.h

@@ -7,6 +7,7 @@
 
 #include <list>
 #include <string>
+#include "base/values.h"
 
 struct BrowserInfo;
 class ChromeDesktopImpl;
@@ -41,6 +42,10 @@ class Chrome {
                                int* width,
                                int* height) = 0;
 
+  // Sets the rect of the specified WebView
+  virtual Status SetWindowRect(const std::string& target_id,
+                               const base::DictionaryValue& params) = 0;
+
   // Sets the size of the specified WebView.
   virtual Status SetWindowSize(const std::string& target_id,
                                int width,
@@ -51,6 +56,20 @@ class Chrome {
                                    int* x,
                                    int* y) = 0;
 
+  // Sets the on-screen position of the specified WebView.
+  virtual Status SetWindowPosition(const std::string& target_id,
+                                   int x,
+                                   int y) = 0;
+
+  // Maximizes specified WebView.
+  virtual Status MaximizeWindow(const std::string& target_id) = 0;
+
+  // Minimizes specified WebView.
+  virtual Status MinimizeWindow(const std::string& target_id) = 0;
+
+  // Opens specified WebView in full screen mode.
+  virtual Status FullScreenWindow(const std::string& target_id) = 0;
+
   // Closes the specified WebView.
   virtual Status CloseWebView(const std::string& id) = 0;
 

chrome/test/chromedriver/chrome/chrome_desktop_impl.cc

@@ -230,133 +230,3 @@ void ChromeDesktopImpl::SetNetworkConnection(
     int network_connection) {
   network_connection_ = network_connection;
 }
-
-Status ChromeDesktopImpl::SetWindowRect(const std::string& target_id,
-                                        const base::DictionaryValue& params) {
-  Window window;
-  Status status = GetWindow(target_id, &window);
-  if (status.IsError())
-    return status;
-
-  auto bounds = std::make_unique<base::DictionaryValue>();
-
-  // fully exit fullscreen
-  if (window.state != "normal") {
-    auto bounds = std::make_unique<base::DictionaryValue>();
-    bounds->SetString("windowState", "normal");
-    status = SetWindowBounds(window.id, std::move(bounds));
-    if (status.IsError())
-      return status;
-  }
-
-  // window position
-  int x = 0;
-  int y = 0;
-  if (params.GetInteger("x", &x) && params.GetInteger("y", &y)) {
-    bounds->SetInteger("left", x);
-    bounds->SetInteger("top", y);
-  }
-  // window size
-  int width = 0;
-  int height = 0;
-  if (params.GetInteger("width", &width) &&
-      params.GetInteger("height", &height)) {
-    bounds->SetInteger("width", width);
-    bounds->SetInteger("height", height);
-  }
-
-  return SetWindowBounds(window.id, std::move(bounds));
-}
-
-Status ChromeDesktopImpl::SetWindowPosition(const std::string& target_id,
-                                            int x,
-                                            int y) {
-  Window window;
-  Status status = GetWindow(target_id, &window);
-  if (status.IsError())
-    return status;
-
-  if (window.state != "normal") {
-    // restore window to normal first to allow position change.
-    auto bounds = std::make_unique<base::DictionaryValue>();
-    bounds->SetString("windowState", "normal");
-    status = SetWindowBounds(window.id, std::move(bounds));
-    if (status.IsError())
-      return status;
-  }
-
-  auto bounds = std::make_unique<base::DictionaryValue>();
-  bounds->SetInteger("left", x);
-  bounds->SetInteger("top", y);
-  return SetWindowBounds(window.id, std::move(bounds));
-}
-
-Status ChromeDesktopImpl::MaximizeWindow(const std::string& target_id) {
-  Window window;
-  Status status = GetWindow(target_id, &window);
-  if (status.IsError())
-    return status;
-
-  if (window.state == "maximized")
-    return Status(kOk);
-
-  if (window.state != "normal") {
-    // always restore window to normal first, since chrome ui doesn't allow
-    // maximizing a minimized or fullscreen window.
-    auto bounds = std::make_unique<base::DictionaryValue>();
-    bounds->SetString("windowState", "normal");
-    status = SetWindowBounds(window.id, std::move(bounds));
-    if (status.IsError())
-      return status;
-  }
-
-  auto bounds = std::make_unique<base::DictionaryValue>();
-  bounds->SetString("windowState", "maximized");
-  return SetWindowBounds(window.id, std::move(bounds));
-}
-
-Status ChromeDesktopImpl::MinimizeWindow(const std::string& target_id) {
-  Window window;
-  Status status = GetWindow(target_id, &window);
-  if (status.IsError())
-    return status;
-
-  if (window.state == "minimized")
-    return Status(kOk);
-
-  if (window.state != "normal") {
-    // restore window to normal first
-    auto bounds = std::make_unique<base::DictionaryValue>();
-    bounds->SetString("windowState", "normal");
-    status = SetWindowBounds(window.id, std::move(bounds));
-    if (status.IsError())
-      return status;
-  }
-
-  auto bounds = std::make_unique<base::DictionaryValue>();
-  bounds->SetString("windowState", "minimized");
-  return SetWindowBounds(window.id, std::move(bounds));
-}
-
-Status ChromeDesktopImpl::FullScreenWindow(const std::string& target_id) {
-  Window window;
-  Status status = GetWindow(target_id, &window);
-  if (status.IsError())
-    return status;
-
-  if (window.state == "fullscreen")
-    return Status(kOk);
-
-  if (window.state != "normal") {
-    auto bounds = std::make_unique<base::DictionaryValue>();
-    bounds->SetString("windowState", "normal");
-    status = SetWindowBounds(window.id, std::move(bounds));
-    if (status.IsError())
-      return status;
-  }
-
-  auto bounds = std::make_unique<base::DictionaryValue>();
-  bounds->SetString("windowState", "fullscreen");
-  return SetWindowBounds(window.id, std::move(bounds));
-}
-

chrome/test/chromedriver/chrome/chrome_desktop_impl.h

@@ -65,13 +65,6 @@ class ChromeDesktopImpl : public ChromeImpl {
   int GetNetworkConnection() const;
   void SetNetworkConnection(int network_connection);
 
-  Status SetWindowRect(const std::string& target_id,
-                       const base::DictionaryValue& params);
-  Status SetWindowPosition(const std::string& target_id, int x, int y);
-  Status MaximizeWindow(const std::string& target_id);
-  Status MinimizeWindow(const std::string& target_id);
-  Status FullScreenWindow(const std::string& target_id);
-
  private:
 
   base::Process process_;

chrome/test/chromedriver/chrome/chrome_impl.cc

@@ -149,6 +149,135 @@ Status ChromeImpl::GetWindowPosition(const std::string& target_id,
   return Status(kOk);
 }
 
+Status ChromeImpl::SetWindowPosition(const std::string& target_id,
+                                            int x,
+                                            int y) {
+  Window window;
+  Status status = GetWindow(target_id, &window);
+  if (status.IsError())
+    return status;
+
+  if (window.state != "normal") {
+    // restore window to normal first to allow position change.
+    auto bounds = std::make_unique<base::DictionaryValue>();
+    bounds->SetString("windowState", "normal");
+    status = SetWindowBounds(window.id, std::move(bounds));
+    if (status.IsError())
+      return status;
+  }
+
+  auto bounds = std::make_unique<base::DictionaryValue>();
+  bounds->SetInteger("left", x);
+  bounds->SetInteger("top", y);
+  return SetWindowBounds(window.id, std::move(bounds));
+}
+
+Status ChromeImpl::MaximizeWindow(const std::string& target_id) {
+  Window window;
+  Status status = GetWindow(target_id, &window);
+  if (status.IsError())
+    return status;
+
+  if (window.state == "maximized")
+    return Status(kOk);
+
+  if (window.state != "normal") {
+    // always restore window to normal first, since chrome ui doesn't allow
+    // maximizing a minimized or fullscreen window.
+    auto bounds = std::make_unique<base::DictionaryValue>();
+    bounds->SetString("windowState", "normal");
+    status = SetWindowBounds(window.id, std::move(bounds));
+    if (status.IsError())
+      return status;
+  }
+
+  auto bounds = std::make_unique<base::DictionaryValue>();
+  bounds->SetString("windowState", "maximized");
+  return SetWindowBounds(window.id, std::move(bounds));
+}
+
+Status ChromeImpl::MinimizeWindow(const std::string& target_id) {
+  Window window;
+  Status status = GetWindow(target_id, &window);
+  if (status.IsError())
+    return status;
+
+  if (window.state == "minimized")
+    return Status(kOk);
+
+  if (window.state != "normal") {
+    // restore window to normal first
+    auto bounds = std::make_unique<base::DictionaryValue>();
+    bounds->SetString("windowState", "normal");
+    status = SetWindowBounds(window.id, std::move(bounds));
+    if (status.IsError())
+      return status;
+  }
+
+  auto bounds = std::make_unique<base::DictionaryValue>();
+  bounds->SetString("windowState", "minimized");
+  return SetWindowBounds(window.id, std::move(bounds));
+}
+
+Status ChromeImpl::FullScreenWindow(const std::string& target_id) {
+  Window window;
+  Status status = GetWindow(target_id, &window);
+  if (status.IsError())
+    return status;
+
+  if (window.state == "fullscreen")
+    return Status(kOk);
+
+  if (window.state != "normal") {
+    auto bounds = std::make_unique<base::DictionaryValue>();
+    bounds->SetString("windowState", "normal");
+    status = SetWindowBounds(window.id, std::move(bounds));
+    if (status.IsError())
+      return status;
+  }
+
+  auto bounds = std::make_unique<base::DictionaryValue>();
+  bounds->SetString("windowState", "fullscreen");
+  return SetWindowBounds(window.id, std::move(bounds));
+}
+
+Status ChromeImpl::SetWindowRect(const std::string& target_id,
+                                        const base::DictionaryValue& params) {
+  Window window;
+  Status status = GetWindow(target_id, &window);
+  if (status.IsError())
+    return status;
+
+  auto bounds = std::make_unique<base::DictionaryValue>();
+
+  // fully exit fullscreen
+  if (window.state != "normal") {
+    auto bounds = std::make_unique<base::DictionaryValue>();
+    bounds->SetString("windowState", "normal");
+    status = SetWindowBounds(window.id, std::move(bounds));
+    if (status.IsError())
+      return status;
+  }
+
+  // window position
+  int x = 0;
+  int y = 0;
+  if (params.GetInteger("x", &x) && params.GetInteger("y", &y)) {
+    bounds->SetInteger("left", x);
+    bounds->SetInteger("top", y);
+  }
+  // window size
+  int width = 0;
+  int height = 0;
+  if (params.GetInteger("width", &width) &&
+      params.GetInteger("height", &height)) {
+    bounds->SetInteger("width", width);
+    bounds->SetInteger("height", height);
+  }
+
+  return SetWindowBounds(window.id, std::move(bounds));
+}
+
 Status ChromeImpl::GetWindowSize(const std::string& target_id,
                                  int* width,
                                  int* height) {

chrome/test/chromedriver/chrome/chrome_impl.h

@@ -39,7 +39,13 @@ class ChromeImpl : public Chrome {
   Status GetWindowSize(const std::string& id, int* width, int* height) override;
   Status SetWindowSize(const std::string& target_id,
                        int width, int height) override;
+  Status SetWindowRect(const std::string& target_id,
+                       const base::DictionaryValue& params) override;
   Status GetWindowPosition(const std::string& id, int* x, int* y) override;
+  Status SetWindowPosition(const std::string& target_id, int x, int y) override;
+  Status MaximizeWindow(const std::string& target_id) override;
+  Status MinimizeWindow(const std::string& target_id) override;
+  Status FullScreenWindow(const std::string& target_id) override;
   Status CloseWebView(const std::string& id) override;
   Status ActivateWebView(const std::string& id) override;
   Status SetAcceptInsecureCerts() override;

chrome/test/chromedriver/chrome/stub_chrome.cc

@@ -48,12 +48,34 @@ Status StubChrome::SetWindowSize(const std::string& id,
   return Status(kOk);
 }
 
+Status StubChrome::SetWindowRect(const std::string& target_id,
+                                 const base::DictionaryValue& params) {
+  return Status(kOk);
+}
+
 Status StubChrome::GetWindowPosition(const std::string& target_id,
                                      int* x,
                                      int* y) {
   return Status(kOk);
 }
 
+Status StubChrome::SetWindowPosition(const std::string& target_id,
+                                     int x, int y) {
+  return Status(kOk);
+}
+
+Status StubChrome::MaximizeWindow(const std::string& target_id) {
+  return Status(kOk);
+}
+
+Status StubChrome::MinimizeWindow(const std::string& target_id) {
+  return Status(kOk);
+}
+
+Status StubChrome::FullScreenWindow(const std::string& target_id) {
+  return Status(kOk);
+}
+
 Status StubChrome::CloseWebView(const std::string& id) {
   return Status(kOk);
 }

chrome/test/chromedriver/chrome/stub_chrome.h

@@ -31,9 +31,15 @@ class StubChrome : public Chrome {
   Status GetWebViewById(const std::string& id, WebView** web_view) override;
   Status GetWindowSize(const std::string& id, int* width, int* height) override;
   Status SetWindowSize(const std::string& id, int width, int height) override;
+  Status SetWindowRect(const std::string& target_id,
+                       const base::DictionaryValue& params) override;
   Status GetWindowPosition(const std::string& target_id,
                            int* x,
                            int* y) override;
+  Status SetWindowPosition(const std::string& target_id, int x, int y) override;
+  Status MaximizeWindow(const std::string& target_id) override;
+  Status MinimizeWindow(const std::string& target_id) override;
+  Status FullScreenWindow(const std::string& target_id) override;
   Status CloseWebView(const std::string& id) override;
   Status ActivateWebView(const std::string& id) override;
   Status SetAcceptInsecureCerts() override;

chrome/test/chromedriver/session_commands.cc

@@ -929,13 +929,9 @@ Status ExecuteSetWindowPosition(Session* session,
   if (!params.GetDouble("x", &x) || !params.GetDouble("y", &y))
     return Status(kUnknownError, "missing or invalid 'x' or 'y'");
 
-  ChromeDesktopImpl* desktop = NULL;
-  Status status = session->chrome->GetAsDesktop(&desktop);
-  if (status.IsError())
-    return status;
-
-  return desktop->SetWindowPosition(session->window, static_cast<int>(x),
-                                      static_cast<int>(y));
+  return session->chrome->SetWindowPosition(session->window,
+                                            static_cast<int>(x),
+                                            static_cast<int>(y));
 }
 
 Status ExecuteGetWindowSize(Session* session,
@@ -963,11 +959,6 @@ Status ExecuteSetWindowRect(Session* session,
   double x = 0;
   double y = 0;
 
-  ChromeDesktopImpl* desktop = NULL;
-  Status status = session->chrome->GetAsDesktop(&desktop);
-  if (status.IsError())
-    return status;
-
   // to pass to the set window rect command
   base::DictionaryValue rect_params;
 
@@ -981,7 +972,7 @@ Status ExecuteSetWindowRect(Session* session,
     rect_params.SetInteger("width", static_cast<int>(width));
     rect_params.SetInteger("height", static_cast<int>(height));
   }
-  status = desktop->SetWindowRect(session->window, rect_params);
+  Status status = session->chrome->SetWindowRect(session->window, rect_params);
   if (status.IsError())
     return status;
 
@@ -1006,12 +997,7 @@ Status ExecuteSetWindowSize(Session* session,
 Status ExecuteMaximizeWindow(Session* session,
                              const base::DictionaryValue& params,
                              std::unique_ptr<base::Value>* value) {
-  ChromeDesktopImpl* desktop = NULL;
-  Status status = session->chrome->GetAsDesktop(&desktop);
-  if (status.IsError())
-    return status;
-
-  status = desktop->MaximizeWindow(session->window);
+  Status status = session->chrome->MaximizeWindow(session->window);
   if (status.IsError())
     return status;
 
@@ -1021,12 +1007,7 @@ Status ExecuteMaximizeWindow(Session* session,
 Status ExecuteMinimizeWindow(Session* session,
                              const base::DictionaryValue& params,
                              std::unique_ptr<base::Value>* value) {
-  ChromeDesktopImpl* desktop = NULL;
-  Status status = session->chrome->GetAsDesktop(&desktop);
-  if (status.IsError())
-    return status;
-
-  status = desktop->MinimizeWindow(session->window);
+  Status status = session->chrome->MinimizeWindow(session->window);
   if (status.IsError())
     return status;
 
@@ -1036,12 +1017,7 @@ Status ExecuteMinimizeWindow(Session* session,
 Status ExecuteFullScreenWindow(Session* session,
                                const base::DictionaryValue& params,
                                std::unique_ptr<base::Value>* value) {
-  ChromeDesktopImpl* desktop = NULL;
-  Status status = session->chrome->GetAsDesktop(&desktop);
-  if (status.IsError())
-    return status;
-
-  status = desktop->FullScreenWindow(session->window);
+  Status status = session->chrome->FullScreenWindow(session->window);
   if (status.IsError())
     return status;