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