add a new set of commands to resize and position windows

chrome/browser/devtools/devtools_sanity_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
 #include "chrome/browser/devtools/device/tcp_device_provider.h"
 #include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/exclusive_access/exclusive_access_context.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_process_policy.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_chrome_web_ui_controller_factory.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/app_modal/javascript_app_modal_dialog.h"
@@ skipping 28 matching lines @@
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_http_job.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/gl/gl_switches.h"
 #include "url/gurl.h"
 
+#if defined(OS_MACOSX)
+#include "ui/base/test/scoped_fake_nswindow_fullscreen.h"
+#endif
+
 using app_modal::AppModalDialog;
 using app_modal::JavaScriptAppModalDialog;
 using app_modal::NativeAppModalDialog;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::NavigationController;
 using content::RenderFrameHost;
 using content::RenderViewHost;
 using content::WebContents;
 using content::WorkerService;
@@ skipping 1962 matching lines @@
   RunTestFunction(window, "testWindowInitializedOnNavigateBack");
 
   DevToolsWindowTesting::CloseDevToolsWindowSync(window);
   content::WebUIControllerFactory::UnregisterFactoryForTesting(&test_factory);
 }
 
 // Tests scripts panel showing.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestDevToolsSharedWorker) {
   RunTest("testDevToolsSharedWorker", url::kAboutBlankURL);
 }
+
+// Encapsulates waiting for the browser window to change state. This is
+// needed for example on Chrome desktop linux, where window state change is done
+// asynchronously as an event received from a different process.
+class CheckWaiter {
+ public:
+  explicit CheckWaiter(base::Callback<bool()> callback, bool expected)
+      : callback_(callback),
+        expected_(expected),
+        timeout_(base::Time::NowFromSystemTime() +
+                 base::TimeDelta::FromMilliseconds(1000)) {}
+  ~CheckWaiter() = default;
+
+  // Blocks until the browser window becomes maximized.
+  void Wait() {
+    if (Check())
+      return;
+
+    base::RunLoop run_loop;
+    quit_ = run_loop.QuitClosure();
+    run_loop.Run();
+  }
+
+ private:
+  bool Check() {
+    if (callback_.Run() != expected_ &&
+        base::Time::NowFromSystemTime() < timeout_) {
+      base::MessageLoop::current()->task_runner()->PostTask(
+          FROM_HERE, base::Bind(base::IgnoreResult(&CheckWaiter::Check),
+                                base::Unretained(this)));
+      return false;
+    }
+
+    // Quit the run_loop to end the wait.
+    if (!quit_.is_null())
+      base::ResetAndReturn(&quit_).Run();
+    return true;
+  }
+
+  base::Callback<bool()> callback_;
+  bool expected_;
+  base::Time timeout_;
+  // The waiter's RunLoop quit closure.
+  base::Closure quit_;
+
+  DISALLOW_COPY_AND_ASSIGN(CheckWaiter);
+};
+
+class DevToolsManagerDelegateTest : public InProcessBrowserTest {
+ public:
+  std::unique_ptr<base::DictionaryValue> SendCommand(std::string state) {
+    auto params = base::MakeUnique<base::DictionaryValue>();
+    auto bounds_object = base::MakeUnique<base::DictionaryValue>();
+    bounds_object->SetString("windowState", state);
+    params->Set("bounds", std::move(bounds_object));
+    params->SetInteger("windowId", browser()->session_id().id());
+    return ChromeDevToolsManagerDelegate::SetWindowBounds(0, params.get());
+  }
+
+  std::unique_ptr<base::DictionaryValue> UpdateBounds() {
+    auto params = base::MakeUnique<base::DictionaryValue>();
+    auto bounds_object = base::MakeUnique<base::DictionaryValue>();
+    bounds_object->SetString("windowState", "normal");
+    bounds_object->SetInteger("left", 200);
+    bounds_object->SetInteger("height", 400);
+    params->Set("bounds", std::move(bounds_object));
+    params->SetInteger("windowId", browser()->session_id().id());
+    return ChromeDevToolsManagerDelegate::SetWindowBounds(0, params.get());
+  }
+
+  void CheckIsMaximized(bool maximized) {
+    CheckWaiter(base::Bind(&BrowserWindow::IsMaximized,
+                           base::Unretained(browser()->window())),
+                maximized)
+        .Wait();
+    EXPECT_EQ(maximized, browser()->window()->IsMaximized());
+  }
+
+  void CheckIsMinimized(bool minimized) {
+    CheckWaiter(base::Bind(&BrowserWindow::IsMinimized,
+                           base::Unretained(browser()->window())),
+                minimized)
+        .Wait();
+    EXPECT_EQ(minimized, browser()->window()->IsMinimized());
+  }
+
+  void CheckIsFullscreen(bool fullscreen) {
+    CheckWaiter(base::Bind(&BrowserWindow::IsFullscreen,
+                           base::Unretained(browser()->window())),
+                fullscreen)
+        .Wait();
+    EXPECT_EQ(fullscreen, browser()->window()->IsFullscreen());
+  }
+
+  bool IsWindowBoundsEqual(gfx::Rect expected) {
+    return browser()->window()->GetBounds() == expected;
+  }
+
+  void CheckWindowBounds(gfx::Rect expected) {
+    CheckWaiter(base::Bind(&DevToolsManagerDelegateTest::IsWindowBoundsEqual,
+                           base::Unretained(this), expected),
+                true)
+        .Wait();
+    EXPECT_EQ(expected, browser()->window()->GetBounds());
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, NormalWindowChangeBounds) {
+  browser()->window()->SetBounds(gfx::Rect(100, 100, 500, 600));
+  CheckWindowBounds(gfx::Rect(100, 100, 500, 600));
+  UpdateBounds();
+  CheckWindowBounds(gfx::Rect(200, 100, 500, 400));
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, NormalToMaximizedWindow) {
+  CheckIsMaximized(false);
+  SendCommand("maximized");
+  CheckIsMaximized(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, NormalToMinimizedWindow) {
+  CheckIsMinimized(false);
+  SendCommand("minimized");
+  CheckIsMinimized(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, NormalToFullscreenWindow) {
+#if defined(OS_MACOSX)
+  ui::test::ScopedFakeNSWindowFullscreen faker;
+#endif
+  CheckIsFullscreen(false);
+  SendCommand("fullscreen");
+#if defined(OS_MACOSX)
+  faker.FinishTransition();
+#endif
+  CheckIsFullscreen(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest,
+                       MaximizedToMinimizedWindow) {
+  browser()->window()->Maximize();
+  CheckIsMaximized(true);
+
+  CheckIsMinimized(false);
+  SendCommand("minimized");
+  CheckIsMinimized(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest,
+                       MaximizedToFullscreenWindow) {
+  browser()->window()->Maximize();
+  CheckIsMaximized(true);
+
+#if defined(OS_MACOSX)
+  ui::test::ScopedFakeNSWindowFullscreen faker;
+#endif
+  CheckIsFullscreen(false);
+  SendCommand("fullscreen");
+#if defined(OS_MACOSX)
+  faker.FinishTransition();
+#endif
+  CheckIsFullscreen(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, ShowMinimizedWindow) {
+  browser()->window()->Minimize();
+  CheckIsMinimized(true);
+  SendCommand("normal");
+  CheckIsMinimized(false);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, RestoreMaximizedWindow) {
+  browser()->window()->Maximize();
+  CheckIsMaximized(true);
+  SendCommand("normal");
+  CheckIsMaximized(false);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, ExitFullscreenWindow) {
+#if defined(OS_MACOSX)
+  ui::test::ScopedFakeNSWindowFullscreen faker;
+#endif
+  browser()->window()->GetExclusiveAccessContext()->EnterFullscreen(
+      GURL(), EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE);
+#if defined(OS_MACOSX)
+  faker.FinishTransition();
+#endif
+  CheckIsFullscreen(true);
+  SendCommand("normal");
+#if defined(OS_MACOSX)
+  faker.FinishTransition();
+#endif
+  CheckIsFullscreen(false);
+}