src/content/browser/devtools/devtools_protocol.h

   1 // Copyright (c) 2013 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 #ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_PROTOCOL_H_
   6 #define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_PROTOCOL_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/callback.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/values.h"
  16 #include "content/common/content_export.h"
  17
  18 namespace content {
  19
  20 // Utility classes for processing DevTools remote debugging messages.
  21 // https://developers.google.com/chrome-developer-tools/docs/debugger-protocol
  22 class DevToolsProtocol {
  23  public:
  24   typedef base::Callback<void(const std::string& message)> Notifier;
  25
  26   class Response;
  27
  28   class Message : public base::RefCountedThreadSafe<Message> {
  29    public:
  30     std::string domain() { return domain_; }
  31     std::string method() { return method_; }
  32     base::DictionaryValue* params() { return params_.get(); }
  33     virtual std::string Serialize() = 0;
  34
  35    protected:
  36     friend class base::RefCountedThreadSafe<Message>;
  37     virtual ~Message();
  38     Message(const std::string& method,
  39             base::DictionaryValue* params);
  40
  41     std::string domain_;
  42     std::string method_;
  43     scoped_ptr<base::DictionaryValue> params_;
  44
  45    private:
  46     DISALLOW_COPY_AND_ASSIGN(Message);
  47   };
  48
  49   class Command : public Message {
  50    public:
  51     int id() { return id_; }
  52
  53     virtual std::string Serialize() OVERRIDE;
  54
  55     // Creates success response. Takes ownership of |result|.
  56     scoped_refptr<Response> SuccessResponse(base::DictionaryValue* result);
  57
  58     // Creates error response.
  59     scoped_refptr<Response> InternalErrorResponse(const std::string& message);
  60
  61     // Creates error response.
  62     scoped_refptr<Response> InvalidParamResponse(const std::string& param);
  63
  64     // Creates error response.
  65     scoped_refptr<Response> NoSuchMethodErrorResponse();
  66
  67     // Creates async response promise.
  68     scoped_refptr<Response> AsyncResponsePromise();
  69
  70    protected:
  71     virtual  ~Command();
  72
  73    private:
  74     friend class DevToolsProtocol;
  75     Command(int id, const std::string& method,
  76             base::DictionaryValue* params);
  77
  78     int id_;
  79
  80     DISALLOW_COPY_AND_ASSIGN(Command);
  81   };
  82
  83   class Response : public base::RefCountedThreadSafe<Response> {
  84    public:
  85     std::string Serialize();
  86
  87     bool is_async_promise() { return is_async_promise_; }
  88
  89    private:
  90     friend class base::RefCountedThreadSafe<Response>;
  91     friend class Command;
  92     friend class DevToolsProtocol;
  93     virtual  ~Response();
  94
  95     Response(int id, base::DictionaryValue* result);
  96     Response(int id, int error_code, const std::string& error_message);
  97
  98     int id_;
  99     scoped_ptr<base::DictionaryValue> result_;
 100     int error_code_;
 101     std::string error_message_;
 102     bool is_async_promise_;
 103
 104     DISALLOW_COPY_AND_ASSIGN(Response);
 105   };
 106
 107   class Notification : public Message {
 108    public:
 109
 110     virtual std::string Serialize() OVERRIDE;
 111
 112    private:
 113     friend class DevToolsProtocol;
 114     virtual ~Notification();
 115
 116     // Takes ownership of |params|.
 117     Notification(const std::string& method,
 118                  base::DictionaryValue* params);
 119
 120     DISALLOW_COPY_AND_ASSIGN(Notification);
 121   };
 122
 123   class CONTENT_EXPORT Handler {
 124    public:
 125     typedef base::Callback<scoped_refptr<DevToolsProtocol::Response>(
 126         scoped_refptr<DevToolsProtocol::Command> command)> CommandHandler;
 127
 128     virtual ~Handler();
 129
 130     virtual scoped_refptr<DevToolsProtocol::Response> HandleCommand(
 131         scoped_refptr<DevToolsProtocol::Command> command);
 132
 133     void SetNotifier(const Notifier& notifier);
 134
 135    protected:
 136     Handler();
 137
 138     void RegisterCommandHandler(const std::string& command,
 139                                 const CommandHandler& handler);
 140
 141     // Sends notification to the client. Takes ownership of |params|.
 142     void SendNotification(const std::string& method,
 143                           base::DictionaryValue* params);
 144
 145     void SendAsyncResponse(scoped_refptr<DevToolsProtocol::Response> response);
 146
 147     // Sends message to client, the caller is presumed to properly
 148     // format the message.
 149     void SendRawMessage(const std::string& message);
 150
 151    private:
 152     typedef std::map<std::string, CommandHandler> CommandHandlers;
 153
 154     Notifier notifier_;
 155     CommandHandlers command_handlers_;
 156
 157     DISALLOW_COPY_AND_ASSIGN(Handler);
 158   };
 159
 160   CONTENT_EXPORT static base::DictionaryValue* ParseMessage(
 161       const std::string& json,
 162       std::string* error_response);
 163
 164   CONTENT_EXPORT static scoped_refptr<Command> ParseCommand(
 165       const std::string& json,
 166       std::string* error_response);
 167
 168   CONTENT_EXPORT static scoped_refptr<Command> ParseCommand(
 169       base::DictionaryValue* command_dict,
 170       std::string* error_response);
 171
 172   CONTENT_EXPORT static scoped_refptr<Command> CreateCommand(
 173       int id,
 174       const std::string& method,
 175       base::DictionaryValue* params);
 176
 177   CONTENT_EXPORT static scoped_refptr<Response> ParseResponse(
 178       base::DictionaryValue* response_dict);
 179
 180   static scoped_refptr<Notification> ParseNotification(
 181       const std::string& json);
 182
 183   static scoped_refptr<Notification> CreateNotification(
 184       const std::string& method, base::DictionaryValue* params);
 185
 186   DevToolsProtocol() {}
 187   ~DevToolsProtocol() {}
 188 };
 189
 190 }  // namespace content
 191
 192 #endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_PROTOCOL_H_