headless: Don't require parameters for all commands

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"
@@ skipping 67 matching lines @@
 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;
-  const base::DictionaryValue* params = nullptr;
   if (!command->GetInteger("id", &id) ||
-      !command->GetString("method", &method) ||
-      !command->GetDictionary("params", &params)) {
+      !command->GetString("method", &method)) {
     return nullptr;
   }
   auto find_it = command_map_.find(method);
   if (find_it == command_map_.end())
     return nullptr;
   CommandMemberFnPtr command_fn_ptr = find_it->second;
+  const base::DictionaryValue* params = nullptr;
+  command->GetDictionary("params", &params);
   std::unique_ptr<base::DictionaryValue> cmd_result(
       ((this)->*command_fn_ptr)(id, params));
   return cmd_result.release();
 }
 
 std::string HeadlessDevToolsManagerDelegate::GetDiscoveryPageHTML() {
   return ResourceBundle::GetSharedInstance()
       .GetRawDataResource(IDR_HEADLESS_LIB_DEVTOOLS_DISCOVERY_PAGE)
       .as_string();
 }
 
 std::string HeadlessDevToolsManagerDelegate::GetFrontendResource(
     const std::string& path) {
   return content::DevToolsFrontendHost::GetFrontendResource(path).as_string();
 }
 
 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();
-  params->GetString("url", &url);
+  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);
   } else {
     context = browser_->GetDefaultBrowserContext();
@@ skipping 14 matching lines @@
           .Build()
           ->Serialize());
   return CreateSuccessResponse(command_id, std::move(result));
 }
 
 std::unique_ptr<base::DictionaryValue>
 HeadlessDevToolsManagerDelegate::CloseTarget(
     int command_id,
     const base::DictionaryValue* params) {
   std::string target_id;
-  if (!params->GetString("targetId", &target_id))
+  if (!params || !params->GetString("targetId", &target_id))
     return CreateInvalidParamResponse(command_id, "targetId");
   HeadlessWebContents* web_contents =
       browser_->GetWebContentsForDevToolsAgentHostId(target_id);
   bool success = false;
   if (web_contents) {
     web_contents->Close();
     success = true;
   }
   std::unique_ptr<base::Value> result(target::CloseTargetResult::Builder()
                                           .SetSuccess(success)
@@ skipping 15 matching lines @@
           .Build()
           ->Serialize());
   return CreateSuccessResponse(command_id, std::move(result));
 }
 
 std::unique_ptr<base::DictionaryValue>
 HeadlessDevToolsManagerDelegate::DisposeBrowserContext(
     int command_id,
     const base::DictionaryValue* params) {
   std::string browser_context_id;
-  if (!params->GetString("browserContextId", &browser_context_id))
+  if (!params || !params->GetString("browserContextId", &browser_context_id))
     return CreateInvalidParamResponse(command_id, "browserContextId");
   HeadlessBrowserContext* context =
       browser_->GetBrowserContextForId(browser_context_id);
 
   bool success = false;
   if (context && context != browser_->GetDefaultBrowserContext() &&
       context->GetAllWebContents().empty()) {
     success = true;
     context->Close();
   }
 
   std::unique_ptr<base::Value> result(
       target::DisposeBrowserContextResult::Builder()
           .SetSuccess(success)
           .Build()
           ->Serialize());
   return CreateSuccessResponse(command_id, std::move(result));
 }
 
 }  // namespace headless