initial version of the headless download manager delegate

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/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_download_manager_delegate.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 {
 
 namespace {
 const char kIdParam[] = "id";
 const char kResultParam[] = "result";
@@ skipping 12 matching lines @@
     std::unique_ptr<base::Value> result) {
   if (!result)
     result = base::MakeUnique<base::DictionaryValue>();
 
   auto response = base::MakeUnique<base::DictionaryValue>();
   response->SetInteger(kIdParam, command_id);
   response->Set(kResultParam, std::move(result));
   return response;
 }
 
+std::unique_ptr<base::DictionaryValue> CreateSuccessResponse(int command_id) {
+  return CreateSuccessResponse(command_id, nullptr);
+}
+
 std::unique_ptr<base::DictionaryValue> CreateErrorResponse(
     int command_id,
     int error_code,
     const std::string& error_message) {
   auto error_object = base::MakeUnique<base::DictionaryValue>();
   error_object->SetInteger(kErrorCodeParam, error_code);
   error_object->SetString(kErrorMessageParam, error_message);
 
   auto response = base::MakeUnique<base::DictionaryValue>();
   response->SetInteger(kIdParam, command_id);
@@ skipping 103 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.setDownloadBehavior"] =
+      base::Bind(&HeadlessDevToolsManagerDelegate::SetDownloadBehavior,
+                 base::Unretained(this));
+  command_map_["Browser.setDownloadDirectory"] =
+      base::Bind(&HeadlessDevToolsManagerDelegate::SetDownloadDirectory,
+                 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) {
@@ skipping 189 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::SetDownloadBehavior(
+    int command_id,
+    const base::DictionaryValue* params) {
+  std::string behavior;
+  if (!params || !params->GetString("behavior", &behavior))
+    return CreateInvalidParamResponse(command_id, "behavior");
+
+  HeadlessDownloadManagerDelegate::DownloadBehavior download_behaviour;
+  if (behavior == "allow") {
+    download_behaviour =
+        HeadlessDownloadManagerDelegate::DownloadBehavior::ALLOW;
+  } else if (behavior == "deny") {
+    download_behaviour =
+        HeadlessDownloadManagerDelegate::DownloadBehavior::DENY;
+  }
+
+  for (HeadlessBrowserContext* hbc : browser_->GetAllBrowserContexts()) {
+    HeadlessBrowserContextImpl* hbci =
+        static_cast<HeadlessBrowserContextImpl*>(hbc);
+
+    HeadlessDownloadManagerDelegate* download_delegate =
+        static_cast<HeadlessDownloadManagerDelegate*>(
+            hbci->GetDownloadManagerDelegate());
+
+    download_delegate->SetDownloadBehavior(download_behaviour);
+  }
+
+  return CreateSuccessResponse(command_id);
+}
+
+std::unique_ptr<base::DictionaryValue>
+HeadlessDevToolsManagerDelegate::SetDownloadDirectory(
+    int command_id,
+    const base::DictionaryValue* params) {
+  std::string path;
+  if (!params || !params->GetString("path", &path))
+    return CreateInvalidParamResponse(command_id, "path");
+
+  for (HeadlessBrowserContext* hbc : browser_->GetAllBrowserContexts()) {
+    HeadlessBrowserContextImpl* hbci =
+        static_cast<HeadlessBrowserContextImpl*>(hbc);
+
+    HeadlessDownloadManagerDelegate* download_delegate =
+        static_cast<HeadlessDownloadManagerDelegate*>(
+            hbci->GetDownloadManagerDelegate());
+
+    download_delegate->SetDownloadDirectory(base::FilePath(path));
+  }
+  return CreateSuccessResponse(command_id);
+}
+
 }  // namespace headless