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/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_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 125 matching lines @@
                  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));
+  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 306 matching lines @@
         command_id, kErrorServerError,
         "To resize minimized/maximized/fullscreen window, restore it to normal "
         "state first.");
   }
 
   web_contents->set_window_state(window_state);
   web_contents->web_contents()->GetRenderWidgetHostView()->SetBounds(bounds);
   return CreateSuccessResponse(command_id, nullptr);
 }
 
+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 =
+      HeadlessDownloadManagerDelegate::DownloadBehavior::DENY;
+
+  if (behavior == "allow") {
+    download_behaviour =
+        HeadlessDownloadManagerDelegate::DownloadBehavior::ALLOW;
+  } else if (behavior == "deny") {
+    download_behaviour =
+        HeadlessDownloadManagerDelegate::DownloadBehavior::DENY;
+  }
+
+  browser_->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");
+
+  browser_->SetDownloadDirectory(base::FilePath(path));
+  return CreateSuccessResponse(command_id);
+}
+
 }  // namespace headless