Add commands to manage tabs and contexts to Browser Domain

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 "base/guid.h"
+#include "content/public/browser/web_contents.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/domains/browser.h"
+
+namespace headless {
+
+HeadlessDevToolsManagerDelegate::HeadlessDevToolsManagerDelegate(
+    HeadlessBrowserImpl* browser)
+    : browser_(browser) {
+  command_map_["Browser.newPage"] = &HeadlessDevToolsManagerDelegate::newPage;
+  command_map_["Browser.closePage"] =
+      &HeadlessDevToolsManagerDelegate::closePage;
+  command_map_["Browser.newContext"] =
+      &HeadlessDevToolsManagerDelegate::newContext;
+  command_map_["Browser.closeContext"] =
+      &HeadlessDevToolsManagerDelegate::closeContext;
+}
+
+HeadlessDevToolsManagerDelegate::~HeadlessDevToolsManagerDelegate() {}
+
+base::DictionaryValue* HeadlessDevToolsManagerDelegate::HandleCommand(
+    content::DevToolsAgentHost* agent_host,
+    base::DictionaryValue* command) {
+  int id;
+  std::string method;
+  const base::DictionaryValue* params = nullptr;
+  if (!command->GetInteger("id", &id) ||
+      !command->GetString("method", &method) ||
+      !command->GetDictionary("params", &params)) {
+    return nullptr;
+  }
+  auto find_it = command_map_.find(method);
+  if (find_it == command_map_.end())
+    return nullptr;
+  CommandMemberFnPtr command_fn_ptr = find_it->second;
+  std::unique_ptr<base::Value> cmd_result(((this)->*command_fn_ptr)(params));
+  if (!cmd_result)
+    return nullptr;
+
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  result->SetInteger("id", id);
+  result->Set("result", std::move(cmd_result));
+  return result.release();
+}
+
+std::unique_ptr<base::Value> HeadlessDevToolsManagerDelegate::newPage(
+    const base::DictionaryValue* params) {
+  std::string initial_url;
+  std::string context_id;
+  int width = 800;
+  int height = 800;
+  params->GetString("initialUrl", &initial_url);
+  params->GetString("contextId", &context_id);
+  params->GetInteger("width", &width);
+  params->GetInteger("height", &height);
+  HeadlessWebContentsImpl* web_contents_impl;
+  auto find_it = browser_context_map_.find(context_id);
+  if (find_it != browser_context_map_.end()) {
+    web_contents_impl = HeadlessWebContentsImpl::From(
+        browser_->CreateWebContentsBuilder()
+            .SetInitialURL(GURL(initial_url))
+            .SetWindowSize(gfx::Size(width, height))
+            .SetBrowserContext(find_it->second.get())
+            .Build());
+  } else {
+    web_contents_impl = HeadlessWebContentsImpl::From(
+        browser_->CreateWebContentsBuilder()
+            .SetInitialURL(GURL(initial_url))
+            .SetWindowSize(gfx::Size(width, height))
+            .Build());
+  }
+  web_contents_map_[web_contents_impl->GetAgentHostId()] = web_contents_impl;
+  return browser::NewPageResult::Builder()
+      .SetPageId(web_contents_impl->GetAgentHostId())
+      .Build()
+      ->Serialize();
+}
+
+std::unique_ptr<base::Value> HeadlessDevToolsManagerDelegate::closePage(
+    const base::DictionaryValue* params) {
+  std::string page_id;
+  if (!params->GetString("pageId", &page_id)) {
+    return nullptr;
+  }
+  auto find_it = web_contents_map_.find(page_id);
+  bool success = false;
+  if (find_it != web_contents_map_.end()) {
+    find_it->second->Close();
+    web_contents_map_.erase(find_it);
+    success = true;
+  }
+  return browser::ClosePageResult::Builder()
+      .SetSuccess(success)
+      .Build()
+      ->Serialize();
+}
+
+std::unique_ptr<base::Value> HeadlessDevToolsManagerDelegate::newContext(
+    const base::DictionaryValue* params) {
+  std::string context_id = base::GenerateGUID();
+  browser_context_map_[context_id] =
+      browser_->CreateBrowserContextBuilder().Build();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  return browser::NewContextResult::Builder()
+      .SetContextId(context_id)
+      .Build()
+      ->Serialize();
+}
+
+std::unique_ptr<base::Value> HeadlessDevToolsManagerDelegate::closeContext(
+    const base::DictionaryValue* params) {
+  std::string context_id;
+  if (!params->GetString("contextId", &context_id)) {
+    return nullptr;
+  }
+  auto find_it = browser_context_map_.find(context_id);
+  bool success = false;
+  if (find_it != browser_context_map_.end()) {
+    success = true;
+    HeadlessBrowserContextImpl* headless_browser_context =
+        HeadlessBrowserContextImpl::From(find_it->second.get());
+    // Make sure |headless_browser_context| isn't in use!
+    for (HeadlessWebContents* headless_web_contents :
+         browser_->GetAllWebContents()) {
+      content::WebContents* web_contents =
+          HeadlessWebContentsImpl::From(headless_web_contents)->web_contents();
+      if (web_contents->GetBrowserContext() == headless_browser_context) {
+        success = false;
+        break;
+      }
+    }
+    if (success)
+      browser_context_map_.erase(find_it);
+  }
+  return browser::CloseContextResult::Builder()
+      .SetSuccess(success)
+      .Build()
+      ->Serialize();
+}
+
+}  // namespace headless