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: domain()30 std::string domain() { return domain_; } method()31 std::string method() { return method_; } params()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: id()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 is_async_promise()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 scoped_refptr<Command> ParseCommand( 161 const std::string& json, 162 std::string* error_response); 163 164 CONTENT_EXPORT static scoped_refptr<Command> CreateCommand( 165 int id, 166 const std::string& method, 167 base::DictionaryValue* params); 168 169 static scoped_refptr<Notification> ParseNotification( 170 const std::string& json); 171 172 static scoped_refptr<Notification> CreateNotification( 173 const std::string& method, base::DictionaryValue* params); 174 175 private: 176 static base::DictionaryValue* ParseMessage(const std::string& json, 177 std::string* error_response); 178 DevToolsProtocol()179 DevToolsProtocol() {} ~DevToolsProtocol()180 ~DevToolsProtocol() {} 181 }; 182 183 } // namespace content 184 185 #endif // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_PROTOCOL_H_ 186