Implement window management devtools commands for headless.

headless/lib/headless_devtools_client_browsertest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #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"
 #include "headless/public/devtools/domains/network.h"
 #include "headless/public/devtools/domains/page.h"
 #include "headless/public/devtools/domains/runtime.h"
 #include "headless/public/devtools/domains/target.h"
 #include "headless/public/headless_browser.h"
 #include "headless/public/headless_devtools_client.h"
 #include "headless/public/headless_devtools_target.h"
@@ skipping 54 matching lines @@
     devtools_client_->GetPage()->GetExperimental()->RemoveObserver(this);
     FinishAsynchronousTest();
   }
 
   // Check that events with no parameters still get a parameters object.
   void OnFrameResized(const page::FrameResizedParams& params) override {}
 };
 
 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:
   void RunDevTooledTest() override {
     std::unique_ptr<runtime::EvaluateParams> params =
         runtime::EvaluateParams::Builder().SetExpression("1 + 2").Build();
     devtools_client_->GetRuntime()->Evaluate(
         std::move(params),
         base::Bind(&HeadlessDevToolsClientEvalTest::OnFirstResult,
                    base::Unretained(this)));
@@ skipping 937 matching lines @@
   }
 
  private:
   bool dev_tools_client_attached_ = false;
   bool dev_tools_client_detached_ = false;
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(DevToolsAttachAndDetachNotifications);
 
 }  // namespace headless