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