Implement window management devtools commands for headless.

headless/lib/headless_devtools_client_browsertest.cc

Index: headless/lib/headless_devtools_client_browsertest.cc
diff --git a/headless/lib/headless_devtools_client_browsertest.cc b/headless/lib/headless_devtools_client_browsertest.cc
index 161d8301af1400ee4f905734a3c53bea9ff7bac0..188ae43e4cbf0c478b8aa532d41cfee15b519493 100644
--- a/headless/lib/headless_devtools_client_browsertest.cc
+++ b/headless/lib/headless_devtools_client_browsertest.cc
@@ -12,6 +12,7 @@
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
+#include "headless/public/devtools/domains/browser.h"
 #include "headless/public/devtools/domains/dom.h"
 #include "headless/public/devtools/domains/emulation.h"
 #include "headless/public/devtools/domains/inspector.h"
@@ -86,6 +87,218 @@ class HeadlessDevToolsClientNavigationTest
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientNavigationTest);
 
+class HeadlessDevToolsClientWindowManagementTest
+    : public HeadlessAsyncDevTooledBrowserTest {
+ public:
+  void SetWindowBounds(
+      const gfx::Rect& rect,
+      base::Callback<void(std::unique_ptr<browser::SetWindowBoundsResult>)>
+          callback) {
+    std::unique_ptr<headless::browser::Bounds> bounds =
+        headless::browser::Bounds::Builder()
+            .SetLeft(rect.x())
+            .SetTop(rect.y())
+            .SetWidth(rect.width())
+            .SetHeight(rect.height())
+            .SetWindowState(browser::WindowState::NORMAL)
+            .Build();
+    std::unique_ptr<browser::SetWindowBoundsParams> params =
+        browser::SetWindowBoundsParams::Builder()
+            .SetWindowId(0)
+            .SetBounds(std::move(bounds))
+            .Build();
+    browser_devtools_client_->GetBrowser()->GetExperimental()->SetWindowBounds(
+        std::move(params), callback);
+  }
+
+  void SetWindowState(
+      const browser::WindowState state,
+      base::Callback<void(std::unique_ptr<browser::SetWindowBoundsResult>)>
+          callback) {
+    std::unique_ptr<headless::browser::Bounds> bounds =
+        headless::browser::Bounds::Builder().SetWindowState(state).Build();
+    std::unique_ptr<browser::SetWindowBoundsParams> params =
+        browser::SetWindowBoundsParams::Builder()
+            .SetWindowId(0)
+            .SetBounds(std::move(bounds))
+            .Build();
+    browser_devtools_client_->GetBrowser()->GetExperimental()->SetWindowBounds(
+        std::move(params), callback);
+  }
+
+  void GetWindowBounds(
+      base::Callback<void(std::unique_ptr<browser::GetWindowBoundsResult>)>
+          callback) {
+    std::unique_ptr<browser::GetWindowBoundsParams> params =
+        browser::GetWindowBoundsParams::Builder().SetWindowId(0).Build();
+    browser_devtools_client_->GetBrowser()->GetExperimental()->GetWindowBounds(
+        std::move(params), callback);
+  }
+
+  void CheckWindowBounds(
+      const gfx::Rect& bounds,
+      const browser::WindowState state,
+      std::unique_ptr<browser::GetWindowBoundsResult> result) {
+    const headless::browser::Bounds* actual_bounds = result->GetBounds();
+    EXPECT_EQ(bounds.x(), actual_bounds->GetLeft());
+    EXPECT_EQ(bounds.y(), actual_bounds->GetTop());
+    EXPECT_EQ(bounds.width(), actual_bounds->GetWidth());
+    EXPECT_EQ(bounds.height(), actual_bounds->GetHeight());
+    EXPECT_EQ(state, actual_bounds->GetWindowState());
+
+    const gfx::Size web_contents_size =
+        HeadlessWebContentsImpl::From(web_contents_)
+            ->web_contents()
+            ->GetRenderWidgetHostView()
+            ->GetViewBounds()
+            .size();
+    EXPECT_EQ(bounds.size(), web_contents_size);
+  }
+};
+
+class HeadlessDevToolsClientWindowStateChangeTest
+    : public HeadlessDevToolsClientWindowManagementTest {
+ public:
+  void OnSetWindowBoundsBackToNormal(
+      std::unique_ptr<browser::SetWindowBoundsResult> result) {
+    GetWindowBounds(base::Bind(&HeadlessDevToolsClientWindowStateChangeTest::
+                                   OnGetWindowBoundsBackToNormal,
+                               base::Unretained(this)));
+  }
+
+  void OnGetWindowBoundsBackToNormal(
+      std::unique_ptr<browser::GetWindowBoundsResult> result) {
+    HeadlessBrowser::Options::Builder builder;
+    const HeadlessBrowser::Options kDefaultOptions = builder.Build();
+    CheckWindowBounds(gfx::Rect(kDefaultOptions.window_size),
+                      browser::WindowState::NORMAL, std::move(result));
+    FinishAsynchronousTest();
+  }
+};
+
+class HeadlessDevToolsClientChangeWindowBoundsTest
+    : public HeadlessDevToolsClientWindowManagementTest {
+  void RunDevTooledTest() override {
+    SetWindowBounds(
+        gfx::Rect(100, 200, 300, 400),
+        base::Bind(
+            &HeadlessDevToolsClientChangeWindowBoundsTest::OnSetWindowBounds,
+            base::Unretained(this)));
+  }
+
+  void OnSetWindowBounds(
+      std::unique_ptr<browser::SetWindowBoundsResult> result) {
+    GetWindowBounds(base::Bind(
+        &HeadlessDevToolsClientChangeWindowBoundsTest::OnGetWindowBounds,
+        base::Unretained(this)));
+  }
+
+  void OnGetWindowBounds(
+      std::unique_ptr<browser::GetWindowBoundsResult> result) {
+    CheckWindowBounds(gfx::Rect(100, 200, 300, 400),
+                      browser::WindowState::NORMAL, std::move(result));
+    FinishAsynchronousTest();
+  }
+};
+
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientChangeWindowBoundsTest);
+
+class HeadlessDevToolsClientMinimizeWindowTest
+    : public HeadlessDevToolsClientWindowStateChangeTest {
+  void RunDevTooledTest() override {
+    SetWindowState(browser::WindowState::MINIMIZED,
+                   base::Bind(&HeadlessDevToolsClientMinimizeWindowTest::
+                                  OnSetWindowBoundsMinimized,
+                              base::Unretained(this)));
+  }
+
+  void OnSetWindowBoundsMinimized(
+      std::unique_ptr<browser::SetWindowBoundsResult> result) {
+    GetWindowBounds(base::Bind(
+        &HeadlessDevToolsClientMinimizeWindowTest::OnGetWindowBoundsMinimized,
+        base::Unretained(this)));
+  }
+
+  void OnGetWindowBoundsMinimized(
+      std::unique_ptr<browser::GetWindowBoundsResult> result) {
+    HeadlessBrowser::Options::Builder builder;
+    const HeadlessBrowser::Options kDefaultOptions = builder.Build();
+    CheckWindowBounds(gfx::Rect(kDefaultOptions.window_size),
+                      browser::WindowState::MINIMIZED, std::move(result));
+
+    SetWindowState(browser::WindowState::NORMAL,
+                   base::Bind(&HeadlessDevToolsClientMinimizeWindowTest::
+                                  OnSetWindowBoundsBackToNormal,
+                              base::Unretained(this)));
+  }
+};
+
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientMinimizeWindowTest);
+
+class HeadlessDevToolsClientMaximizeWindowTest
+    : public HeadlessDevToolsClientWindowStateChangeTest {
+  void RunDevTooledTest() override {
+    SetWindowState(browser::WindowState::MAXIMIZED,
+                   base::Bind(&HeadlessDevToolsClientMaximizeWindowTest::
+                                  OnSetWindowBoundsMaximized,
+                              base::Unretained(this)));
+  }
+
+  void OnSetWindowBoundsMaximized(
+      std::unique_ptr<browser::SetWindowBoundsResult> result) {
+    GetWindowBounds(base::Bind(
+        &HeadlessDevToolsClientMaximizeWindowTest::OnGetWindowBoundsMaximized,
+        base::Unretained(this)));
+  }
+
+  void OnGetWindowBoundsMaximized(
+      std::unique_ptr<browser::GetWindowBoundsResult> result) {
+    HeadlessBrowser::Options::Builder builder;
+    const HeadlessBrowser::Options kDefaultOptions = builder.Build();
+    CheckWindowBounds(gfx::Rect(kDefaultOptions.screen_size),
+                      browser::WindowState::MAXIMIZED, std::move(result));
+
+    SetWindowState(browser::WindowState::NORMAL,
+                   base::Bind(&HeadlessDevToolsClientMaximizeWindowTest::
+                                  OnSetWindowBoundsBackToNormal,
+                              base::Unretained(this)));
+  }
+};
+
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientMaximizeWindowTest);
+
+class HeadlessDevToolsClientFullscreenWindowTest
+    : public HeadlessDevToolsClientWindowStateChangeTest {
+  void RunDevTooledTest() override {
+    SetWindowState(browser::WindowState::FULLSCREEN,
+                   base::Bind(&HeadlessDevToolsClientFullscreenWindowTest::
+                                  OnSetWindowBoundsFullscreen,
+                              base::Unretained(this)));
+  }
+
+  void OnSetWindowBoundsFullscreen(
+      std::unique_ptr<browser::SetWindowBoundsResult> result) {
+    GetWindowBounds(base::Bind(&HeadlessDevToolsClientFullscreenWindowTest::
+                                   OnGetWindowBoundsFullscreen,
+                               base::Unretained(this)));
+  }
+
+  void OnGetWindowBoundsFullscreen(
+      std::unique_ptr<browser::GetWindowBoundsResult> result) {
+    HeadlessBrowser::Options::Builder builder;
+    const HeadlessBrowser::Options kDefaultOptions = builder.Build();
+    CheckWindowBounds(gfx::Rect(kDefaultOptions.screen_size),
+                      browser::WindowState::FULLSCREEN, std::move(result));
+
+    SetWindowState(browser::WindowState::NORMAL,
+                   base::Bind(&HeadlessDevToolsClientFullscreenWindowTest::
+                                  OnSetWindowBoundsBackToNormal,
+                              base::Unretained(this)));
+  }
+};
+
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientFullscreenWindowTest);
+
 class HeadlessDevToolsClientEvalTest
     : public HeadlessAsyncDevTooledBrowserTest {
  public: