Implement window management devtools commands for headless.

headless/lib/browser/headless_devtools_manager_delegate.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 "headless/lib/browser/headless_devtools_manager_delegate.h"
 
 #include <string>
 #include <utility>
 
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_frontend_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "headless/grit/headless_lib_resources.h"
 #include "headless/lib/browser/headless_browser_context_impl.h"
 #include "headless/lib/browser/headless_browser_impl.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
 #include "headless/public/devtools/domains/target.h"
 #include "printing/units.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace headless {
@@ skipping 38 matching lines @@
 }
 
 std::unique_ptr<base::DictionaryValue> CreateInvalidParamResponse(
     int command_id,
     const std::string& param) {
   return CreateErrorResponse(
       command_id, kErrorInvalidParam,
       base::StringPrintf("Missing or invalid '%s' parameter", param.c_str()));
 }
 
+gfx::Rect BoundsOnScreen(const HeadlessBrowserWindow* window,
+                         const gfx::Size& screen_size) {
+  if (window->state() == "maximized" || window->state() == "fullscreen")
+    return gfx::Rect(screen_size);
+  return window->bounds();
+}
+
+std::unique_ptr<base::DictionaryValue> CreateBoundsDict(
+    const HeadlessBrowserWindow* window,
+    const gfx::Size& screen_size) {
+  auto bounds_object = base::MakeUnique<base::DictionaryValue>();
+  gfx::Rect bounds = BoundsOnScreen(window, screen_size);
+  bounds_object->SetInteger("left", bounds.x());
+  bounds_object->SetInteger("top", bounds.y());
+  bounds_object->SetInteger("width", bounds.width());
+  bounds_object->SetInteger("height", bounds.height());
+  bounds_object->SetString("windowState", window->state());
+  return bounds_object;
+}
+
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
 void PDFCreated(
     const content::DevToolsManagerDelegate::CommandCallback& callback,
     int command_id,
     printing::HeadlessPrintManager::PrintResult print_result,
     const std::string& data) {
   std::unique_ptr<base::DictionaryValue> response;
   if (print_result == printing::HeadlessPrintManager::PRINT_SUCCESS) {
     response = CreateSuccessResponse(
         command_id,
@@ skipping 81 matching lines @@
   command_map_["Target.createTarget"] = base::Bind(
       &HeadlessDevToolsManagerDelegate::CreateTarget, base::Unretained(this));
   command_map_["Target.closeTarget"] = base::Bind(
       &HeadlessDevToolsManagerDelegate::CloseTarget, base::Unretained(this));
   command_map_["Target.createBrowserContext"] =
       base::Bind(&HeadlessDevToolsManagerDelegate::CreateBrowserContext,
                  base::Unretained(this));
   command_map_["Target.disposeBrowserContext"] =
       base::Bind(&HeadlessDevToolsManagerDelegate::DisposeBrowserContext,
                  base::Unretained(this));
+  command_map_["Browser.getWindowForTarget"] =
+      base::Bind(&HeadlessDevToolsManagerDelegate::GetWindowForTarget,
+                 base::Unretained(this));
+  command_map_["Browser.getWindowBounds"] =
+      base::Bind(&HeadlessDevToolsManagerDelegate::GetWindowBounds,
+                 base::Unretained(this));
+  command_map_["Browser.setWindowBounds"] =
+      base::Bind(&HeadlessDevToolsManagerDelegate::SetWindowBounds,
+                 base::Unretained(this));
 
   async_command_map_["Page.printToPDF"] = base::Bind(
       &HeadlessDevToolsManagerDelegate::PrintToPDF, base::Unretained(this));
 }
 
 HeadlessDevToolsManagerDelegate::~HeadlessDevToolsManagerDelegate() {}
 
 base::DictionaryValue* HeadlessDevToolsManagerDelegate::HandleCommand(
     content::DevToolsAgentHost* agent_host,
     base::DictionaryValue* command) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!browser_)
     return nullptr;
 
   int id;
   std::string method;
   if (!command->GetInteger("id", &id) || !command->GetString("method", &method))
     return nullptr;
 
   auto find_it = command_map_.find(method);
   if (find_it == command_map_.end())
     return nullptr;
 
+  // Only handle Browser domain commands from Browser DevToolsAgentHost.

[Eric Seckler, 2017/05/22 19:13:40]

nit: Handle Browser domain commands only from ...

[jzfeng, 2017/05/24 05:05:39]

Done.

+  if (method.find("Browser.") == 0 &&
+      agent_host->GetType() != content::DevToolsAgentHost::kTypeBrowser)
+    return nullptr;
+
   const base::DictionaryValue* params = nullptr;
   command->GetDictionary("params", &params);
   auto cmd_result = find_it->second.Run(id, params);
   return cmd_result.release();
 }
 
 bool HeadlessDevToolsManagerDelegate::HandleAsyncCommand(
     content::DevToolsAgentHost* agent_host,
     base::DictionaryValue* command,
     const CommandCallback& callback) {
@@ skipping 13 matching lines @@
 
   const base::DictionaryValue* params = nullptr;
   command->GetDictionary("params", &params);
   find_it->second.Run(agent_host, id, params, callback);
   return true;
 }
 
 scoped_refptr<content::DevToolsAgentHost>
 HeadlessDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
   HeadlessBrowserContext* context = browser_->GetDefaultBrowserContext();
-  HeadlessWebContentsImpl* web_contents_impl = HeadlessWebContentsImpl::From(
-      context->CreateWebContentsBuilder()
-          .SetInitialURL(url)
-          .SetWindowSize(browser_->options()->window_size)
-          .Build());
+  gfx::Rect bounds =
+      BoundsOnScreen(browser_->window(), browser_->options()->screen_size);
+  HeadlessWebContentsImpl* web_contents_impl =
+      HeadlessWebContentsImpl::From(context->CreateWebContentsBuilder()
+                                        .SetInitialURL(url)
+                                        .SetWindowSize(bounds.size())
+                                        .Build());
   return content::DevToolsAgentHost::GetOrCreateFor(
       web_contents_impl->web_contents());
 }
 
 std::string HeadlessDevToolsManagerDelegate::GetDiscoveryPageHTML() {
   return ResourceBundle::GetSharedInstance()
       .GetRawDataResource(IDR_HEADLESS_LIB_DEVTOOLS_DISCOVERY_PAGE)
       .as_string();
 }
 
@@ skipping 28 matching lines @@
                                    "Printing is not enabled"));
 #endif
 }
 
 std::unique_ptr<base::DictionaryValue>
 HeadlessDevToolsManagerDelegate::CreateTarget(
     int command_id,
     const base::DictionaryValue* params) {
   std::string url;
   std::string browser_context_id;
-  int width = browser_->options()->window_size.width();
-  int height = browser_->options()->window_size.height();
+  gfx::Rect bounds =
+      BoundsOnScreen(browser_->window(), browser_->options()->screen_size);
+  int width = bounds.width();
+  int height = bounds.height();
   if (!params || !params->GetString("url", &url))
     return CreateInvalidParamResponse(command_id, "url");
   params->GetString("browserContextId", &browser_context_id);
   params->GetInteger("width", &width);
   params->GetInteger("height", &height);
 
   HeadlessBrowserContext* context =
       browser_->GetBrowserContextForId(browser_context_id);
   if (!browser_context_id.empty()) {
     context = browser_->GetBrowserContextForId(browser_context_id);
@@ skipping 77 matching lines @@
   }
 
   std::unique_ptr<base::Value> result(
       target::DisposeBrowserContextResult::Builder()
           .SetSuccess(success)
           .Build()
           ->Serialize());
   return CreateSuccessResponse(command_id, std::move(result));
 }
 
+std::unique_ptr<base::DictionaryValue>
+HeadlessDevToolsManagerDelegate::GetWindowForTarget(
+    int command_id,
+    const base::DictionaryValue* params) {
+  std::string target_id;
+  if (!params->GetString("targetId", &target_id))
+    return CreateInvalidParamResponse(command_id, "targetId");
+
+  bool found_web_contents = false;
+  for (HeadlessBrowserContext* context : browser_->GetAllBrowserContexts()) {
+    if (context->GetWebContentsForDevToolsAgentHostId(target_id)) {
+      found_web_contents = true;
+      break;
+    }
+  }
+  if (!found_web_contents) {
+    return CreateErrorResponse(command_id, kErrorServerError,
+                               "No web contents for the given target id");
+  }
+
+  auto result = base::MakeUnique<base::DictionaryValue>();
+  result->SetInteger("windowId", 0);

[Sami, 2017/05/22 16:30:57]

Let's make this a named constant -- and also non-zero to avoid confusing
clients.

+  result->Set("bounds", CreateBoundsDict(browser_->window(),
+                                         browser_->options()->screen_size));
+  return CreateSuccessResponse(command_id, std::move(result));
+}
+
+std::unique_ptr<base::DictionaryValue>
+HeadlessDevToolsManagerDelegate::GetWindowBounds(
+    int command_id,
+    const base::DictionaryValue* params) {
+  int window_id;
+  if (!params->GetInteger("windowId", &window_id))
+    return CreateInvalidParamResponse(command_id, "windowId");
+  if (window_id != 0) {
+    return CreateErrorResponse(command_id, kErrorServerError,
+                               "Browser window not found");
+  }
+
+  auto result = base::MakeUnique<base::DictionaryValue>();
+  result->Set("bounds", CreateBoundsDict(browser_->window(),
+                                         browser_->options()->screen_size));
+  return CreateSuccessResponse(command_id, std::move(result));
+}
+
+std::unique_ptr<base::DictionaryValue>
+HeadlessDevToolsManagerDelegate::SetWindowBounds(
+    int command_id,
+    const base::DictionaryValue* params) {
+  int window_id;
+  if (!params->GetInteger("windowId", &window_id))
+    return CreateInvalidParamResponse(command_id, "windowId");
+  if (window_id != 0) {
+    return CreateErrorResponse(command_id, kErrorServerError,
+                               "Browser window not found");
+  }
+
+  const base::Value* value = nullptr;
+  const base::DictionaryValue* bounds_dict = nullptr;
+  if (!params->Get("bounds", &value) || !value->GetAsDictionary(&bounds_dict))
+    return CreateInvalidParamResponse(command_id, "bounds");
+
+  std::string window_state;
+  if (!bounds_dict->GetString("windowState", &window_state))

[Sami, 2017/05/22 16:30:57]

nit: Add {}s please

[jzfeng, 2017/05/24 05:05:39]

Done.

+    window_state = "normal";
+  else if (window_state != "normal" && window_state != "minimized" &&
+           window_state != "maximized" && window_state != "fullscreen")
+    return CreateInvalidParamResponse(command_id, "windowState");
+
+  // Compute updated bounds when window state is normal.
+  bool set_bounds = false;
+  gfx::Rect bounds = browser_->window()->bounds();
+  int left, top, width, height;
+  if (bounds_dict->GetInteger("left", &left)) {
+    bounds.set_x(left);
+    set_bounds = true;
+  }
+  if (bounds_dict->GetInteger("top", &top)) {
+    bounds.set_y(top);
+    set_bounds = true;
+  }
+  if (bounds_dict->GetInteger("width", &width)) {
+    if (width < 0)
+      return CreateInvalidParamResponse(command_id, "width");
+    bounds.set_width(width);
+    set_bounds = true;
+  }
+  if (bounds_dict->GetInteger("height", &height)) {
+    if (height < 0)
+      return CreateInvalidParamResponse(command_id, "height");
+    bounds.set_height(height);
+    set_bounds = true;
+  }
+
+  if (set_bounds && window_state != "normal") {
+    return CreateErrorResponse(
+        command_id, kErrorServerError,
+        "The 'minimized', 'maximized' and 'fullscreen' states cannot be "
+        "combined with 'left', 'top', 'width' or 'height'");
+  }
+
+  if (set_bounds && browser_->window()->state() != "normal") {
+    return CreateErrorResponse(
+        command_id, kErrorServerError,
+        "To resize minimized/maximized/fullscreen window, restore it to normal "
+        "state first.");
+  }
+
+  browser_->window()->set_state(window_state);
+
+  if (window_state == "minimized")
+    return CreateSuccessResponse(command_id, nullptr);
+
+  if (window_state == "maximized" || window_state == "fullscreen")
+    bounds = gfx::Rect(browser_->options()->screen_size);
+  else
+    browser_->window()->set_bounds(bounds);
+
+  for (HeadlessBrowserContext* context : browser_->GetAllBrowserContexts()) {
+    for (HeadlessWebContents* web_contents : context->GetAllWebContents()) {

[Eric Seckler, 2017/05/22 19:13:40]

We should allow controlling the window size of individual WebContents
independently.

+      auto* contents = HeadlessWebContentsImpl::From(web_contents);
+      if (contents) {
+        contents->web_contents()->GetRenderWidgetHostView()->SetSize(
+            bounds.size());
+      }
+    }
+  }
+
+  return CreateSuccessResponse(command_id, nullptr);
+}
+
 }  // namespace headless