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 error response.
  68     scoped_refptr<Response> ServerErrorResponse(const std::string& message);
  69
  70     // Creates async response promise.
  71     scoped_refptr<Response> AsyncResponsePromise();
  72
  73    protected:
  74     virtual  ~Command();
  75
  76    private:
  77     friend class DevToolsProtocol;
  78     Command(int id, const std::string& method,
  79             base::DictionaryValue* params);
  80
  81     int id_;
  82
  83     DISALLOW_COPY_AND_ASSIGN(Command);
  84   };
  85
  86   class Response : public base::RefCountedThreadSafe<Response> {
  87    public:
  88     std::string Serialize();
  89
  90     bool is_async_promise() { return is_async_promise_; }
  91
  92    private:
  93     friend class base::RefCountedThreadSafe<Response>;
  94     friend class Command;
  95     friend class DevToolsProtocol;
  96     virtual  ~Response();
  97
  98     Response(int id, base::DictionaryValue* result);
  99     Response(int id, int error_code, const std::string& error_message);
 100
 101     int id_;
 102     scoped_ptr<base::DictionaryValue> result_;
 103     int error_code_;
 104     std::string error_message_;
 105     bool is_async_promise_;
 106
 107     DISALLOW_COPY_AND_ASSIGN(Response);
 108   };
 109
 110   class Notification : public Message {
 111    public:
 112
 113     virtual std::string Serialize() OVERRIDE;
 114
 115    private:
 116     friend class DevToolsProtocol;
 117     virtual ~Notification();
 118
 119     // Takes ownership of |params|.
 120     Notification(const std::string& method,
 121                  base::DictionaryValue* params);
 122
 123     DISALLOW_COPY_AND_ASSIGN(Notification);
 124   };
 125
 126   class CONTENT_EXPORT Handler {
 127    public:
 128     typedef base::Callback<scoped_refptr<DevToolsProtocol::Response>(
 129         scoped_refptr<DevToolsProtocol::Command> command)> CommandHandler;
 130     typedef base::Callback<void(
 131         scoped_refptr<DevToolsProtocol::Notification> notification)>
 132             NotificationHandler;
 133
 134     virtual ~Handler();
 135
 136     virtual scoped_refptr<DevToolsProtocol::Response> HandleCommand(
 137         scoped_refptr<DevToolsProtocol::Command> command);
 138
 139     virtual void HandleNotification(
 140         scoped_refptr<DevToolsProtocol::Notification> notification);
 141
 142     void SetNotifier(const Notifier& notifier);
 143
 144    protected:
 145     Handler();
 146
 147     void RegisterCommandHandler(const std::string& command,
 148                                 const CommandHandler& handler);
 149
 150     void RegisterNotificationHandler(const std::string& notification,
 151                                      const NotificationHandler& handler);
 152
 153     // Sends notification to the client. Takes ownership of |params|.
 154     void SendNotification(const std::string& method,
 155                           base::DictionaryValue* params);
 156
 157     void SendAsyncResponse(scoped_refptr<DevToolsProtocol::Response> response);
 158
 159     // Sends message to client, the caller is presumed to properly
 160     // format the message.
 161     void SendRawMessage(const std::string& message);
 162
 163    private:
 164     typedef std::map<std::string, CommandHandler> CommandHandlers;
 165     typedef std::map<std::string, NotificationHandler> NotificationHandlers;
 166
 167     Notifier notifier_;
 168     CommandHandlers command_handlers_;
 169     NotificationHandlers notification_handlers_;
 170
 171     DISALLOW_COPY_AND_ASSIGN(Handler);
 172   };
 173
 174   CONTENT_EXPORT static base::DictionaryValue* ParseMessage(
 175       const std::string& json,
 176       std::string* error_response);
 177
 178   CONTENT_EXPORT static scoped_refptr<Command> ParseCommand(
 179       const std::string& json,
 180       std::string* error_response);
 181
 182   CONTENT_EXPORT static scoped_refptr<Command> ParseCommand(
 183       base::DictionaryValue* command_dict,
 184       std::string* error_response);
 185
 186   CONTENT_EXPORT static scoped_refptr<Command> CreateCommand(
 187       int id,
 188       const std::string& method,
 189       base::DictionaryValue* params);
 190
 191   CONTENT_EXPORT static scoped_refptr<Response> ParseResponse(
 192       base::DictionaryValue* response_dict);
 193
 194   static scoped_refptr<Notification> ParseNotification(
 195       const std::string& json);
 196
 197   static scoped_refptr<Notification> CreateNotification(
 198       const std::string& method, base::DictionaryValue* params);
 199
 200   DevToolsProtocol() {}
 201   ~DevToolsProtocol() {}
 202 };
 203
 204 }  // namespace content
 205
 206 #endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_PROTOCOL_H_