DevTools: allow embedder handling remote debugger commands.

content/browser/devtools/devtools_protocol.cc

 // Copyright (c) 2013 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 "content/browser/devtools/devtools_protocol.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/stringprintf.h"
 
@@ skipping 198 matching lines @@
     return false;
   return true;
 }
 
 // static
 scoped_refptr<DevToolsProtocol::Command> DevToolsProtocol::ParseCommand(
     const std::string& json,
     std::string* error_response) {
   scoped_ptr<base::DictionaryValue> command_dict(
       ParseMessage(json, error_response));
+  return ParseCommand(command_dict.get(), error_response);
+}
+
+// static
+scoped_refptr<DevToolsProtocol::Command> DevToolsProtocol::ParseCommand(
+    base::DictionaryValue* command_dict,
+    std::string* error_response) {
   if (!command_dict)
     return NULL;
 
   int id;
   std::string method;
   bool ok = command_dict->GetInteger(kIdParam, &id) && id >= 0;
-  ok = ok && ParseMethod(command_dict.get(), &method);
+  ok = ok && ParseMethod(command_dict, &method);
   if (!ok) {
     scoped_refptr<Response> response =
         new Response(kNoId, kErrorInvalidRequest, "No such method");
     *error_response = response->Serialize();
     return NULL;
   }
 
   base::DictionaryValue* params = NULL;
   command_dict->GetDictionary(kParamsParam, &params);
   return new Command(id, method, params ? params->DeepCopy() : NULL);
 }
 
 // static
 scoped_refptr<DevToolsProtocol::Command>
 DevToolsProtocol::CreateCommand(
     int id,
     const std::string& method,
     base::DictionaryValue* params) {
   return new Command(id, method, params);
 }
 
+//static
+scoped_refptr<DevToolsProtocol::Response>
+DevToolsProtocol::ParseResponse(
+    base::DictionaryValue* response_dict) {
+  int id;
+  if (!response_dict->GetInteger(kIdParam, &id))
+    id = kNoId;
+
+  int error_code;
+  if (!response_dict->GetInteger(kErrorCodeParam, &error_code))
+    return new Response(id, kErrorInternalError, "Invalid response");
+
+  if (error_code) {
+    std::string error_message;
+    response_dict->GetString(kErrorMessageParam, &error_message);
+    return new Response(id, error_code, error_message);
+  }
+
+  const base::DictionaryValue* result = NULL;
+  response_dict->GetDictionary(kResultParam, &result);
+  return new Response(id, result ? result->DeepCopy() : NULL);
+}
+
 // static
 scoped_refptr<DevToolsProtocol::Notification>
 DevToolsProtocol::ParseNotification(const std::string& json) {
   scoped_ptr<base::DictionaryValue> dict(ParseMessage(json, NULL));
   if (!dict)
     return NULL;
 
   std::string method;
   bool ok = ParseMethod(dict.get(), &method);
   if (!ok)
@@ skipping 27 matching lines @@
         new Response(0, kErrorParseError, error_message);
     if (error_response)
       *error_response = response->Serialize();
     return NULL;
   }
 
   return static_cast<base::DictionaryValue*>(message.release());
 }
 
 }  // namespace content