content/browser/devtools/protocol/devtools_protocol_client.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/devtools/protocol/devtools_protocol_client.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/strings/stringprintf.h"
   9
  10 namespace content {
  11
  12 namespace {
  13
  14 const char kIdParam[] = "id";
  15 const char kMethodParam[] = "method";
  16 const char kParamsParam[] = "params";
  17 const char kResultParam[] = "result";
  18 const char kErrorParam[] = "error";
  19 const char kErrorCodeParam[] = "code";
  20 const char kErrorMessageParam[] = "message";
  21
  22 // Special values.
  23 const int kStatusOk = -1;
  24 const int kStatusFallThrough = -2;
  25 // JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
  26 const int kStatusInvalidParams = -32602;
  27 const int kStatusInternalError = -32603;
  28 const int kStatusServerError = -32000;
  29
  30 }  // namespace
  31
  32 // static
  33 const DevToolsCommandId DevToolsProtocolClient::kNoId = -1;
  34
  35 DevToolsProtocolClient::DevToolsProtocolClient(
  36     const RawMessageCallback& raw_message_callback)
  37     : raw_message_callback_(raw_message_callback) {
  38 }
  39
  40 DevToolsProtocolClient::~DevToolsProtocolClient() {
  41 }
  42
  43 void DevToolsProtocolClient::SendRawMessage(const std::string& message) {
  44   raw_message_callback_.Run(message);
  45 }
  46
  47 void DevToolsProtocolClient::SendMessage(const base::DictionaryValue& message) {
  48   std::string json_message;
  49   base::JSONWriter::Write(&message, &json_message);
  50   SendRawMessage(json_message);
  51 }
  52
  53 void DevToolsProtocolClient::SendNotification(
  54     const std::string& method,
  55     scoped_ptr<base::DictionaryValue> params) {
  56   base::DictionaryValue notification;
  57   notification.SetString(kMethodParam, method);
  58   if (params)
  59     notification.Set(kParamsParam, params.release());
  60
  61   SendMessage(notification);
  62 }
  63
  64 void DevToolsProtocolClient::SendSuccess(
  65     DevToolsCommandId command_id,
  66     scoped_ptr<base::DictionaryValue> params) {
  67   base::DictionaryValue response;
  68   response.SetInteger(kIdParam, command_id);
  69
  70   response.Set(kResultParam,
  71       params ? params.release() : new base::DictionaryValue());
  72
  73   SendMessage(response);
  74 }
  75
  76 bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id,
  77                                        const Response& response) {
  78   if (response.status() == kStatusOk ||
  79       response.status() == kStatusFallThrough) {
  80     return false;
  81   }
  82   base::DictionaryValue dict;
  83   if (command_id == kNoId)
  84     dict.Set(kIdParam, base::Value::CreateNullValue());
  85   else
  86     dict.SetInteger(kIdParam, command_id);
  87
  88   base::DictionaryValue* error_object = new base::DictionaryValue();
  89   error_object->SetInteger(kErrorCodeParam, response.status());
  90   if (!response.message().empty())
  91     error_object->SetString(kErrorMessageParam, response.message());
  92
  93   dict.Set(kErrorParam, error_object);
  94   SendMessage(dict);
  95   return true;
  96 }
  97
  98 typedef DevToolsProtocolClient::Response Response;
  99
 100 Response Response::FallThrough() {
 101   return Response(kStatusFallThrough);
 102 }
 103
 104 Response Response::OK() {
 105   return Response(kStatusOk);
 106 }
 107
 108 Response Response::InvalidParams(const std::string& param) {
 109   return Response(kStatusInvalidParams,
 110       base::StringPrintf("Missing or invalid '%s' parameter", param.c_str()));
 111 }
 112
 113 Response Response::InternalError(const std::string& message) {
 114   return Response(kStatusInternalError, message);
 115 }
 116
 117 Response Response::ServerError(const std::string& message) {
 118   return Response(kStatusServerError, message);
 119 }
 120
 121 int Response::status() const {
 122   return status_;
 123 }
 124
 125 const std::string& Response::message() const {
 126   return message_;
 127 }
 128
 129 bool Response::IsFallThrough() const {
 130   return status_ == kStatusFallThrough;
 131 }
 132
 133 Response::Response(int status)
 134     : status_(status) {
 135 }
 136
 137 Response::Response(int status, const std::string& message)
 138     : status_(status),
 139       message_(message) {
 140 }
 141
 142 }  // namespace content