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 "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_protocol_constants.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/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"
 #include "components/app_modal/native_app_modal_dialog.h"
@@ skipping 1545 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) {}
+  ~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::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_;
+
+  // 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) {
+    std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue);
+    base::DictionaryValue* bounds_object = new base::DictionaryValue();
+    bounds_object->SetString("windowState", state);
+    params->Set("bounds", bounds_object);
+    params->SetInteger("windowId", browser()->session_id().id());
+    return ChromeDevToolsManagerDelegate::SetWindowBounds(0, params.release());
+  }
+
+  void CheckIsMaximized(bool maximized) {
+    CheckWaiter(base::Bind(&BrowserWindow::IsMaximized,
+                           base::Unretained(browser()->window())),
+                maximized)
+        .Wait();
+  }
+
+  void CheckIsMinimized(bool minimized) {
+    CheckWaiter(base::Bind(&BrowserWindow::IsMinimized,
+                           base::Unretained(browser()->window())),
+                minimized)
+        .Wait();
+  }
+
+  void CheckIsFullscreen(bool fullscreen) {
+    CheckWaiter(base::Bind(&BrowserWindow::IsFullscreen,
+                           base::Unretained(browser()->window())),
+                fullscreen)
+        .Wait();
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, MaximizeWindow) {
+  browser()->window()->SetBounds(gfx::Rect(500, 600));
+  CheckIsMaximized(false);
+  SendCommand("maximized");
+  CheckIsMaximized(true);
+
+  browser()->window()->Restore();
+  browser()->window()->Minimize();
+  CheckIsMaximized(false);
+  CheckIsMinimized(true);
+  SendCommand("maximized");
+  CheckIsMaximized(true);
+  CheckIsMinimized(false);
+
+  browser()->window()->Restore();
+  browser()->window()->GetExclusiveAccessContext()->EnterFullscreen(
+      GURL(), EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE);
+  CheckIsMaximized(false);
+  CheckIsFullscreen(true);
+  SendCommand("maximized");
+  CheckIsMaximized(true);
+  CheckIsFullscreen(false);
+
+  browser()->window()->Maximize();
+  CheckIsMaximized(true);
+  SendCommand("maximized");
+  CheckIsMaximized(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, MinimizeWindow) {
+  browser()->window()->SetBounds(gfx::Rect(500, 600));
+  CheckIsMinimized(false);
+  SendCommand("minimized");
+  CheckIsMinimized(true);
+
+  browser()->window()->Show();
+  browser()->window()->Maximize();
+  CheckIsMinimized(false);
+  CheckIsMaximized(true);
+  SendCommand("minimized");
+  CheckIsMinimized(true);
+
+  browser()->window()->Show();
+  browser()->window()->GetExclusiveAccessContext()->EnterFullscreen(
+      GURL(), EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE);
+  CheckIsMinimized(false);
+  CheckIsFullscreen(true);
+  SendCommand("minimized");
+  CheckIsMinimized(true);
+  CheckIsFullscreen(false);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsManagerDelegateTest, FullscreenWindow) {
+  browser()->window()->SetBounds(gfx::Rect(500, 600));
+  CheckIsFullscreen(false);
+  SendCommand("fullscreen");
+  CheckIsFullscreen(true);
+
+  browser()->window()->GetExclusiveAccessContext()->ExitFullscreen();
+  browser()->window()->Maximize();
+  CheckIsFullscreen(false);
+  CheckIsMaximized(true);
+  SendCommand("fullscreen");
+  CheckIsFullscreen(true);
+
+  browser()->window()->GetExclusiveAccessContext()->ExitFullscreen();
+  browser()->window()->Minimize();
+  CheckIsFullscreen(false);
+  CheckIsMinimized(true);
+  SendCommand("fullscreen");
+  CheckIsFullscreen(true);
+}