diff options
Diffstat (limited to 'content/browser/devtools/protocol')
19 files changed, 1730 insertions, 0 deletions
diff --git a/content/browser/devtools/protocol/devtools_protocol_client.cc b/content/browser/devtools/protocol/devtools_protocol_client.cc new file mode 100644 index 0000000..a0d9547 --- /dev/null +++ b/content/browser/devtools/protocol/devtools_protocol_client.cc @@ -0,0 +1,93 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/devtools_protocol_client.h" + +namespace content { + +DevToolsProtocolClient::DevToolsProtocolClient( + const EventCallback& event_callback, + const ResponseCallback& response_callback) + : event_callback_(event_callback), + response_callback_(response_callback) { +} + +DevToolsProtocolClient::~DevToolsProtocolClient() { +} + +void DevToolsProtocolClient::SendNotification(const std::string& method, + base::DictionaryValue* params) { + event_callback_.Run(method, params); +} + +void DevToolsProtocolClient::SendAsyncResponse( + scoped_refptr<DevToolsProtocol::Response> response) { + response_callback_.Run(response); +} + +void DevToolsProtocolClient::SendInvalidParamsResponse( + scoped_refptr<DevToolsProtocol::Command> command, + const std::string& message) { + SendAsyncResponse(command->InvalidParamResponse(message)); +} + +void DevToolsProtocolClient::SendInternalErrorResponse( + scoped_refptr<DevToolsProtocol::Command> command, + const std::string& message) { + SendAsyncResponse(command->InternalErrorResponse(message)); +} + +void DevToolsProtocolClient::SendServerErrorResponse( + scoped_refptr<DevToolsProtocol::Command> command, + const std::string& message) { + SendAsyncResponse(command->ServerErrorResponse(message)); +} + +typedef DevToolsProtocolClient::Response Response; + +Response Response::FallThrough() { + Response response; + response.status_ = ResponseStatus::RESPONSE_STATUS_FALLTHROUGH; + return response; +} + +Response Response::OK() { + Response response; + response.status_ = ResponseStatus::RESPONSE_STATUS_OK; + return response; +} + +Response Response::InvalidParams(const std::string& message) { + Response response; + response.status_ = ResponseStatus::RESPONSE_STATUS_INVALID_PARAMS; + response.message_ = message; + return response; +} + +Response Response::InternalError(const std::string& message) { + Response response; + response.status_ = ResponseStatus::RESPONSE_STATUS_INTERNAL_ERROR; + response.message_ = message; + return response; +} + +Response Response::ServerError(const std::string& message) { + Response response; + response.status_ = ResponseStatus::RESPONSE_STATUS_SERVER_ERROR; + response.message_ = message; + return response; +} + +DevToolsProtocolClient::ResponseStatus Response::status() const { + return status_; +} + +const std::string& Response::message() const { + return message_; +} + +Response::Response() { +} + +} // namespace content diff --git a/content/browser/devtools/protocol/devtools_protocol_client.h b/content/browser/devtools/protocol/devtools_protocol_client.h new file mode 100644 index 0000000..b2f95b7 --- /dev/null +++ b/content/browser/devtools/protocol/devtools_protocol_client.h @@ -0,0 +1,76 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_CLIENT_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_CLIENT_H_ + +#include "content/browser/devtools/devtools_protocol.h" + +namespace content { + +class DevToolsProtocolClient { + public: + typedef base::Callback<void(const std::string& event, + base::DictionaryValue* params)> EventCallback; + + typedef base::Callback<void(scoped_refptr<DevToolsProtocol::Response>)> + ResponseCallback; + + enum ResponseStatus { + RESPONSE_STATUS_FALLTHROUGH, + RESPONSE_STATUS_OK, + RESPONSE_STATUS_INVALID_PARAMS, + RESPONSE_STATUS_INTERNAL_ERROR, + RESPONSE_STATUS_SERVER_ERROR, + }; + + struct Response { + public: + static Response FallThrough(); + static Response OK(); + static Response InvalidParams(const std::string& message); + static Response InternalError(const std::string& message); + static Response ServerError(const std::string& message); + + ResponseStatus status() const; + const std::string& message() const; + + private: + Response(); + + ResponseStatus status_; + std::string message_; + }; + + void SendInvalidParamsResponse( + scoped_refptr<DevToolsProtocol::Command> command, + const std::string& message); + void SendInternalErrorResponse( + scoped_refptr<DevToolsProtocol::Command> command, + const std::string& message); + void SendServerErrorResponse( + scoped_refptr<DevToolsProtocol::Command> command, + const std::string& message); + + protected: + DevToolsProtocolClient(const EventCallback& event_callback, + const ResponseCallback& response_callback); + + virtual ~DevToolsProtocolClient(); + + void SendNotification(const std::string& method, + base::DictionaryValue* params); + + void SendAsyncResponse(scoped_refptr<DevToolsProtocol::Response> response); + + private: + EventCallback event_callback_; + ResponseCallback response_callback_; + + DISALLOW_COPY_AND_ASSIGN(DevToolsProtocolClient); +}; + +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_CLIENT_H_ diff --git a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py new file mode 100755 index 0000000..aa7c507 --- /dev/null +++ b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py @@ -0,0 +1,777 @@ +#!/usr/bin/env python +# Copyright 2014 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import sys +import string +import json + +input_json_path = sys.argv[1] +output_cc_path = sys.argv[2] +output_h_path = sys.argv[3] + +header = """\ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// THIS FILE IS AUTOGENERATED. DO NOT EDIT. +// Generated by +// content/public/browser/devtools_protocol_handler_generator.py from +// third_party/WebKit/Source/devtools/protocol.json +""" + +template_h = string.Template(header + """\ + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_ + +#include "content/browser/devtools/devtools_protocol.h" +#include "content/browser/devtools/protocol/devtools_protocol_client.h" + +namespace content { + +class DevToolsProtocolHandlerImpl; + +namespace devtools { + +${types}\ + +} // namespace devtools + +class DevToolsProtocolHandlerImpl : public DevToolsProtocol::Handler { + public: + typedef DevToolsProtocolClient::Response Response; + typedef DevToolsProtocolClient::ResponseStatus ResponseStatus; + + DevToolsProtocolHandlerImpl(); + virtual ~DevToolsProtocolHandlerImpl(); + +${setters}\ + + private: +${friends}\ + +${methods}\ + +${fields}\ +}; + +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_ +""") + +tmpl_typedef = string.Template("""\ +namespace ${domain} { +typedef ${param_type} ${declared_name}; +} // namespace ${domain} +""") + +tmpl_struct = string.Template("""\ +namespace ${domain} { +struct ${declared_name} { + public: + ${declared_name}(); + +${methods}\ + + private: + friend class ::content::DevToolsProtocolHandlerImpl; + +${fields}\ +}; +} // namespace ${domain} +""") + +tmpl_struct_setter = string.Template("""\ + void set_${param}(${pass_type} ${param}); +""") + +tmpl_struct_field = string.Template("""\ + ${param_type} ${param}_; + bool has_${param}_; +""") + +tmpl_enum = string.Template("""\ +namespace ${domain} { +namespace ${command_underscored} { +${values}\ +} // namespace ${command_underscored} +} // namespace ${domain} +""") + +tmpl_enum_value = string.Template("""\ +extern const char k${Param}${Value}[]; +""") + +tmpl_enum_value_def = string.Template("""\ +const char k${Param}${Value}[] = "${value}"; +""") + +tmpl_handler = string.Template("""\ +namespace ${domain} { +class ${Domain}Handler; +} // namespace domain +""") + +tmpl_client = string.Template("""\ +namespace ${domain} { +class Client : public DevToolsProtocolClient { + public: + Client(const EventCallback& event_callback, + const ResponseCallback& response_callback); + virtual ~Client(); + +${methods}\ +}; +} // namespace ${domain} +""") + +tmpl_event = string.Template("""\ + void ${Command}( + const ${Command}Params& params); +""") + +tmpl_response = string.Template("""\ + void Send${Command}Response( + scoped_refptr<DevToolsProtocol::Command> command, + const ${Command}Response& params); +""") + +tmpl_setter = string.Template("""\ + void Set${Domain}Handler( + devtools::${domain}::${Domain}Handler* ${domain}_handler); +""") + +tmpl_friend = string.Template("""\ + friend class devtools::${domain}::Client; +""") + +tmpl_callback = string.Template("""\ + scoped_refptr<DevToolsProtocol::Response> + On${Domain}${Command}( + scoped_refptr<DevToolsProtocol::Command> command); +""") + +tmpl_to_value = string.Template("""\ + static base::DictionaryValue* ToValue( + const devtools::${domain}::${declared_name}& src); +""") + +tmpl_field = string.Template("""\ + devtools::${domain}::${Domain}Handler* ${domain}_handler_; +""") + +template_cc = string.Template(header + """\ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +#include "base/bind.h" +${includes}\ + +namespace content { + +DevToolsProtocolHandlerImpl::DevToolsProtocolHandlerImpl() + : ${fields_init} { +} + +DevToolsProtocolHandlerImpl::~DevToolsProtocolHandlerImpl() { +} + +namespace { + +typedef DevToolsProtocolClient::ResponseStatus ResponseStatus; + +bool CreateCommonResponse( + scoped_refptr<DevToolsProtocol::Command> command, + const DevToolsProtocolClient::Response& response, + scoped_refptr<DevToolsProtocol::Response>* protocol_response) { + switch (response.status()) { + case ResponseStatus::RESPONSE_STATUS_FALLTHROUGH: + *protocol_response = NULL; + break; + case ResponseStatus::RESPONSE_STATUS_OK: + return false; + case ResponseStatus::RESPONSE_STATUS_INVALID_PARAMS: + *protocol_response = command->InvalidParamResponse(response.message()); + break; + case ResponseStatus::RESPONSE_STATUS_INTERNAL_ERROR: + *protocol_response = command->InternalErrorResponse(response.message()); + break; + case ResponseStatus::RESPONSE_STATUS_SERVER_ERROR: + *protocol_response = command->ServerErrorResponse(response.message()); + break; + } + return true; +} + +} // namespace + +${methods}\ + +namespace devtools { + +${types}\ + +} // namespace devtools + +} // namespace content +""") + +tmpl_include = string.Template("""\ +#include "content/browser/devtools/protocol/${domain}_handler.h" +""") + +tmpl_field_init = string.Template("${domain}_handler_(NULL)") + +tmpl_setter_impl = string.Template("""\ +void DevToolsProtocolHandlerImpl::Set${Domain}Handler( + devtools::${domain}::${Domain}Handler* ${domain}_handler) { + DCHECK(!${domain}_handler_); + ${domain}_handler_ = ${domain}_handler; +${initializations}\ +} +""") + +tmpl_register = string.Template("""\ + RegisterCommandHandler( + "${Domain}.${command}", + base::Bind( + &DevToolsProtocolHandlerImpl::On${Domain}${Command}, + base::Unretained(this))); +""") + +tmpl_init_client = string.Template("""\ + ${domain}_handler_->SetClient(make_scoped_ptr( + new devtools::${domain}::Client( + base::Bind(&DevToolsProtocolHandlerImpl::SendNotification, + base::Unretained(this)), + base::Bind(&DevToolsProtocolHandlerImpl::SendAsyncResponse, + base::Unretained(this))))); +""") + +tmpl_callback_impl = string.Template("""\ +scoped_refptr<DevToolsProtocol::Response> +DevToolsProtocolHandlerImpl::On${Domain}${Command}( + scoped_refptr<DevToolsProtocol::Command> command) { +${prep}\ + Response response = ${domain}_handler_->${Command}(${args}); + scoped_refptr<DevToolsProtocol::Response> protocol_response; + if (CreateCommonResponse(command, response, &protocol_response)) + return protocol_response; + base::DictionaryValue* dict = new base::DictionaryValue(); +${wrap}\ + return command->SuccessResponse(dict); +} +""") + +tmpl_callback_async_impl = string.Template("""\ +scoped_refptr<DevToolsProtocol::Response> +DevToolsProtocolHandlerImpl::On${Domain}${Command}( + scoped_refptr<DevToolsProtocol::Command> command) { +${prep}\ + return ${domain}_handler_->${Command}(${args}); +} +""") + +params_prep = """\ + base::DictionaryValue* params = command->params(); +""" + +tmpl_prep_req = string.Template("""\ + ${param_type} in_${param}${init}; + if (!params || + !params->Get${Type}("${proto_param}", &in_${param})) + return command->InvalidParamResponse("${proto_param}"); +""") + +tmpl_prep_req_list = string.Template("""\ + base::ListValue* list_${param} = NULL; + if (!params || !params->GetList("${proto_param}", &list_${param})) + return command->InvalidParamResponse("${proto_param}"); + ${param_type} in_${param}; + for (base::ListValue::const_iterator it = + list_${param}->begin(); it != list_${param}->end(); ++it) { + ${item_type} item${item_init}; + if (!(*it)->GetAs${ItemType}(&item)) + return command->InvalidParamResponse("${proto_param}"); + in_${param}.push_back(item); + } +""") + +tmpl_prep_opt = string.Template("""\ + ${param_type} in_${param}${init}; + bool ${param}_found = params && params->Get${Type}( + "${proto_param}", + &in_${param}); +""") + +tmpl_prep_output = string.Template("""\ + ${param_type} out_${param}${init}; +""") + +tmpl_arg_req = string.Template("in_${param}") + +tmpl_arg_opt = string.Template( + "${param}_found ?\n &in_${param} : NULL") + +tmpl_arg_output = string.Template("&out_${param}") + +tmpl_to_value_impl = string.Template("""\ +// static +base::DictionaryValue* DevToolsProtocolHandlerImpl::ToValue( + const devtools::${domain}::${declared_name}& src) { + base::DictionaryValue* dict = new base::DictionaryValue(); +${dchecks}\ +${wrap}\ + return dict; +} +""") + +tmpl_dcheck = string.Template("""\ + DCHECK(${cond_name}); +""") + +tmpl_struct_impl = string.Template("""\ +namespace ${domain} { + +${declared_name}::${declared_name}()${fields} { +} + +${methods}\ + +} // namespace ${domain} +""") + +tmpl_struct_field_init = string.Template("has_${param}_(false)") + +tmpl_struct_setter_impl = string.Template("""\ +void ${declared_name}::set_${param}( + ${pass_type} ${param}) { + ${param}_ = ${param}; + has_${param}_ = true; +} +""") + +tmpl_client_impl = string.Template("""\ +namespace ${domain} { + +Client::Client(const EventCallback& event_callback, + const ResponseCallback& response_callback) + : DevToolsProtocolClient(event_callback, response_callback) { +} + +Client::~Client() { +} + +${methods}\ + +} // namespace ${domain} +""") + +tmpl_event_impl = string.Template("""\ +void Client::${Command}( + const ${Command}Params& params) { + SendNotification("${Domain}.${command}", + DevToolsProtocolHandlerImpl::ToValue(params)); +} +""") + +tmpl_response_impl = string.Template("""\ +void Client::Send${Command}Response( + scoped_refptr<DevToolsProtocol::Command> command, + const ${Command}Response& params) { + SendAsyncResponse( + command->SuccessResponse(DevToolsProtocolHandlerImpl::ToValue(params))); +} +""") + +tmpl_wrap = string.Template("""\ + dict->Set${Type}("${proto_param}", ${var_name}); +""") + +tmpl_wrap_dict = string.Template("""\ + dict->Set("${proto_param}", + DevToolsProtocolHandlerImpl::ToValue(${var_name})); +""") + +tmpl_wrap_obj = string.Template("""\ + dict->Set("${proto_param}", ${var_name}); +""") + +tmpl_wrap_list = string.Template("""\ + base::ListValue* list_${param} = new base::ListValue(); + for (${param_type}::const_iterator it = + ${var_name}.begin(); it != ${var_name}.end(); ++it) { +${append}\ + } + dict->Set("${proto_param}", list_${param}); +""") + +tmpl_append = string.Template("""\ + list_${param}->Append${Type}(*it); +""") + +tmpl_append_dict = string.Template("""\ + list_${param}->Append(DevToolsProtocolHandlerImpl::ToValue(*it)); +""") + +tmpl_append_obj = string.Template("""\ + list_${param}->Append(*it); +""") + +tmpl_wrap_opt = string.Template("""\ + if (${cond_name}) + dict->Set${Type}("${proto_param}", ${var_name}); +""") + +tmpl_typename = string.Template("devtools::${domain}::${declared_name}") + +def Capitalize(s): + return s[:1].upper() + s[1:] + +def Decapitalize(s): + return s.lower() + +def Uncamelcase(s): + result = "" + for i, c in enumerate(s): + if c.isupper(): + if (i > 0) and ((i < len(s)-1) and s[i+1].islower() or s[i-1].islower()): + result += "_" + result += c.lower() + else: + result += c + return result + +types = {} +json_api = json.loads(open(input_json_path, "r").read()) +type_decls = [] +type_impls = [] +handler_methods = [] +handler_method_impls = [] + +for json_domain in json_api["domains"]: + if "types" in json_domain: + for json_type in json_domain["types"]: + types["%s.%s" % (json_domain["domain"], json_type["id"])] = json_type + +def DeclareStruct(json_properties, mapping): + methods = [] + fields = [] + fields_init = [] + method_impls = [] + dchecks = [] + wrap = [] + for json_prop in json_properties: + prop_map = mapping.copy() + prop_map["proto_param"] = json_prop["name"] + prop_map["param"] = Uncamelcase(json_prop["name"]) + prop_map["var_name"] = "src.%s_" % prop_map["param"] + prop_map["cond_name"] = "src.has_%s_" % prop_map["param"] + ResolveType(json_prop, prop_map) + prop_map["declared_name"] = mapping["declared_name"] + methods.append(tmpl_struct_setter.substitute(prop_map)) + fields.append(tmpl_struct_field.substitute(prop_map)) + fields_init.append(tmpl_struct_field_init.substitute(prop_map)) + method_impls.append(tmpl_struct_setter_impl.substitute(prop_map)) + if json_prop.get("optional"): + if param_map["Type"] in ["List", "Dictionary"]: + # TODO(vkuzkokov) Implement. + raise Exception( + "Optional array and object properties are not implemented") + wrap.append(tmpl_wrap_opt.substitute(prop_map)) + else: + dchecks.append(tmpl_dcheck.substitute(prop_map)); + if not "wrap" in prop_map: + raise Exception("Arrays of arrays are not implemented") + wrap.append(prop_map["wrap"]) + + type_decls.append(tmpl_struct.substitute(mapping, + methods = "".join(methods), + fields = "".join(fields))) + fields_init_str = "" + if len(fields_init) > 0: + fields_init_str = "\n : " + (",\n ".join(fields_init)) + type_impls.append(tmpl_struct_impl.substitute(mapping, + fields = fields_init_str, + methods = "\n".join(method_impls))) + handler_methods.append(tmpl_to_value.substitute(mapping)) + handler_method_impls.append(tmpl_to_value_impl.substitute(mapping, + dchecks = "".join(dchecks), + wrap = "".join(wrap))) + +def ResolveRef(json, mapping): + dot_pos = json["$ref"].find(".") + if dot_pos == -1: + domain_name = mapping["Domain"] + type_name = json["$ref"] + else: + domain_name = json["$ref"][:dot_pos] + type_name = json["$ref"][dot_pos + 1:] + json_type = types["%s.%s" % (domain_name, type_name)] + mapping["declared_name"] = Capitalize(type_name) + mapping["Domain"] = domain_name + mapping["domain"] = Decapitalize(domain_name) + mapping["param_type"] = tmpl_typename.substitute(mapping) + if json_type.get("enum"): + # TODO(vkuzkokov) Implement. Approximate template: + # namespace ${domain} { const char k${declared_name}${Value}; } + raise Exception("Named enumerations are not implemented") + ResolveType(json_type, mapping) + if not "___struct_declared" in json_type: + json_type["___struct_declared"] = True; + if (json_type.get("type") == "object") and ("properties" in json_type): + DeclareStruct(json_type["properties"], mapping) + else: + type_decls.append(tmpl_typedef.substitute(mapping)) + mapping["param_type"] = tmpl_typename.substitute(mapping) + +def ResolveArray(json, mapping): + items_map = mapping.copy() + ResolveType(json["items"], items_map) + mapping["param_type"] = "std::vector<%s>" % items_map["param_type"] + mapping["Type"] = "List" + if "append" in items_map: + mapping["wrap"] = tmpl_wrap_list.substitute(mapping, + append = items_map["append"]) + mapping["pass_type"] = "const %s&" % mapping["param_type"] + mapping["prep_req"] = tmpl_prep_req_list.substitute(mapping, + item_type = items_map["param_type"], + item_init = items_map["init"], + ItemType = items_map["Type"]) + # TODO(vkuzkokov) mapping["append"]: template for array of arrays. + +def ResolveObject(json, mapping): + mapping["Type"] = "Dictionary" + if "properties" in json: + if not "declared_name" in mapping: + mapping["declared_name"] = ("%s%s" % + (mapping["Command"], Capitalize(mapping["proto_param"]))) + mapping["param_type"] = tmpl_typename.substitute(mapping) + DeclareStruct(json["properties"], mapping) + mapping["append"] = tmpl_append_dict.substitute(mapping) + mapping["wrap"] = tmpl_wrap_dict.substitute(mapping) + mapping["pass_type"] = "const %s&" % mapping["param_type"] + else: + mapping["param_type"] = "base::DictionaryValue*" + mapping["append"] = tmpl_append_obj.substitute(mapping) + mapping["wrap"] = tmpl_wrap_obj.substitute(mapping) + mapping["pass_type"] = mapping["param_type"] + +def ResolvePrimitive(json, mapping): + jsonrpc_type = json["type"] + if jsonrpc_type == "boolean": + mapping["param_type"] = "bool" + mapping["Type"] = "Boolean" + mapping["init"] = " = false" + elif jsonrpc_type == "integer": + mapping["param_type"] = "int" + mapping["Type"] = "Integer" + mapping["init"] = " = 0" + elif jsonrpc_type == "number": + mapping["param_type"] = "double" + mapping["Type"] = "Double" + mapping["init"] = " = 0.0" + elif jsonrpc_type == "string": + mapping["param_type"] = "std::string" + mapping["pass_type"] = "const std::string&" + mapping["Type"] = "String" + if "enum" in json: + values = [] + value_defs = [] + mapping["command_underscored"] = Uncamelcase(mapping["command"]) + mapping["Param"] = Capitalize(mapping["proto_param"]) + for enum_value in json["enum"]: + values.append(tmpl_enum_value.substitute(mapping, + Value = Capitalize(enum_value))) + value_defs.append(tmpl_enum_value_def.substitute(mapping, + value = enum_value, + Value = Capitalize(enum_value))) + type_decls.append(tmpl_enum.substitute(mapping, + values = "".join(values))) + type_impls.append(tmpl_enum.substitute(mapping, + values = "".join(value_defs))) + else: + raise Exception("Unknown type: %s" % json_type) + mapping["wrap"] = tmpl_wrap.substitute(mapping) + mapping["append"] = tmpl_append.substitute(mapping) + mapping["prep_req"] = tmpl_prep_req.substitute(mapping) + if jsonrpc_type != "string": + mapping["pass_type"] = mapping["param_type"] + +def ResolveType(json, mapping): + mapping["init"] = "" + if "$ref" in json: + ResolveRef(json, mapping) + elif "type" in json: + jsonrpc_type = json["type"] + if jsonrpc_type == "array": + ResolveArray(json, mapping) + elif jsonrpc_type == "object": + ResolveObject(json, mapping) + else: + ResolvePrimitive(json, mapping) + else: + raise Exception("Unknown type at %s.%s %s" % + (mapping["Domain"], mapping["command"], mapping["proto_param"])) + +setters = [] +friends = [] +fields = [] + +includes = [] +fields_init = [] + +for json_domain in json_api["domains"]: + domain_map = {} + domain_map["Domain"] = json_domain["domain"] + domain_map["domain"] = Decapitalize(json_domain["domain"]) + + initializations = [] + client_methods = [] + client_method_impls = [] + domain_empty = True + domain_needs_client = False + + if "commands" in json_domain: + for json_command in json_domain["commands"]: + if (not ("handlers" in json_command) or + not ("browser" in json_command["handlers"])): + continue + domain_empty = False + + command_map = domain_map.copy() + command_map["command"] = json_command["name"] + command_map["Command"] = Capitalize(json_command["name"]) + + prep = [] + args = [] + + if "parameters" in json_command: + for json_param in json_command["parameters"]: + param_map = command_map.copy() + param_map["proto_param"] = json_param["name"] + param_map["param"] = Uncamelcase(json_param["name"]) + param_map["var_name"] = "in_%s" % param_map["param"] + + ResolveType(json_param, param_map) + if len(prep) == 0: + prep.append(params_prep) + if json_param.get("optional"): + if param_map["Type"] in ["List", "Dictionary"]: + # TODO(vkuzkokov) Implement transformation of base::ListValue + # to std::vector and base::DictonaryValue to struct. + raise Exception( + "Optional array and object parameters are not implemented") + prep.append(tmpl_prep_opt.substitute(param_map)) + args.append(tmpl_arg_opt.substitute(param_map)) + else: + prep.append(param_map["prep_req"]) + args.append(tmpl_arg_req.substitute(param_map)) + + if json_command.get("async"): + domain_needs_client = True + json_returns = [] + if "returns" in json_command: + json_returns = json_command["returns"] + command_map["declared_name"] = "%sResponse" % command_map["Command"] + DeclareStruct(json_returns, command_map) + # TODO(vkuzkokov) Pass async callback instance similar to how + # InspectorBackendDispatcher does it. This, however, can work + # only if Blink and Chrome are in the same repo. + args.append("command") + handler_method_impls.append( + tmpl_callback_async_impl.substitute(command_map, + prep = "".join(prep), + args = "\n " + ",\n ".join(args))) + client_methods.append(tmpl_response.substitute(command_map)) + client_method_impls.append(tmpl_response_impl.substitute(command_map)) + else: + wrap = [] + if "returns" in json_command: + for json_param in json_command["returns"]: + param_map = command_map.copy() + param_map["proto_param"] = json_param["name"] + param_map["param"] = Uncamelcase(json_param["name"]) + param_map["var_name"] = "out_%s" % param_map["param"] + + if json_param.get("optional"): + # TODO(vkuzkokov) Implement Optional<T> for value types. + raise Exception("Optional return values are not implemented") + ResolveType(json_param, param_map) + prep.append(tmpl_prep_output.substitute(param_map)) + args.append(tmpl_arg_output.substitute(param_map)) + if not "wrap" in param_map: + raise Exception("Arrays of arrays are not implemented") + wrap.append(param_map["wrap"]) + + args_str = "" + if len(args) > 0: + args_str = "\n " + ",\n ".join(args) + handler_method_impls.append(tmpl_callback_impl.substitute(command_map, + prep = "".join(prep), + args = args_str, + wrap = "".join(wrap))) + + initializations.append(tmpl_register.substitute(command_map)) + handler_methods.append(tmpl_callback.substitute(command_map)) + + if "events" in json_domain: + for json_event in json_domain["events"]: + if (not ("handlers" in json_event) or + not ("browser" in json_event["handlers"])): + continue + domain_empty = False + domain_needs_client = True + + event_map = domain_map.copy() + event_map["command"] = json_event["name"] + event_map["Command"] = Capitalize(json_event["name"]) + + json_parameters = [] + if "parameters" in json_event: + json_parameters = json_event["parameters"] + event_map["declared_name"] = "%sParams" % event_map["Command"] + DeclareStruct(json_parameters, event_map); + + client_methods.append(tmpl_event.substitute(event_map)) + client_method_impls.append(tmpl_event_impl.substitute(event_map)) + + if domain_empty: + continue + type_decls.append(tmpl_handler.substitute(domain_map)) + setters.append(tmpl_setter.substitute(domain_map)) + fields.append(tmpl_field.substitute(domain_map)) + includes.append(tmpl_include.substitute(domain_map)) + fields_init.append(tmpl_field_init.substitute(domain_map)) + if domain_needs_client: + type_decls.append(tmpl_client.substitute(domain_map, + methods = "".join(client_methods))) + friends.append(tmpl_friend.substitute(domain_map)) + initializations.append(tmpl_init_client.substitute(domain_map)) + type_impls.append(tmpl_client_impl.substitute(domain_map, + methods = "\n".join(client_method_impls))) + handler_method_impls.append(tmpl_setter_impl.substitute(domain_map, + initializations = "".join(initializations))) + + +output_h_file = open(output_h_path, "w") +output_cc_file = open(output_cc_path, "w") + +output_h_file.write(template_h.substitute({}, + types = "\n".join(type_decls), + setters = "".join(setters), + friends = "".join(friends), + methods = "".join(handler_methods), + fields = "".join(fields))) +output_h_file.close() + +output_cc_file.write(template_cc.substitute({}, + includes = "".join(sorted(includes)), + fields_init = ",\n ".join(fields_init), + methods = "\n".join(handler_method_impls), + types = "\n".join(type_impls))) +output_cc_file.close() diff --git a/content/browser/devtools/protocol/dom_handler.cc b/content/browser/devtools/protocol/dom_handler.cc new file mode 100644 index 0000000..8453335 --- /dev/null +++ b/content/browser/devtools/protocol/dom_handler.cc @@ -0,0 +1,26 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/dom_handler.h" + +namespace content { +namespace devtools { +namespace dom { + +typedef DevToolsProtocolClient::Response Response; + +DOMHandler::DOMHandler() { +} + +DOMHandler::~DOMHandler() { +} + +Response DOMHandler::SetFileInputFiles(NodeId node_id, + const std::vector<std::string>& files) { + return Response::FallThrough(); +} + +} // namespace dom +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/dom_handler.h b/content/browser/devtools/protocol/dom_handler.h new file mode 100644 index 0000000..9718426 --- /dev/null +++ b/content/browser/devtools/protocol/dom_handler.h @@ -0,0 +1,32 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DOM_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DOM_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { +namespace devtools { +namespace dom { + +class DOMHandler { + public: + typedef DevToolsProtocolClient::Response Response; + + DOMHandler(); + virtual ~DOMHandler(); + + Response SetFileInputFiles(NodeId node_id, + const std::vector<std::string>& files); + + private: + DISALLOW_COPY_AND_ASSIGN(DOMHandler); +}; + +} // namespace dom +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DOM_HANDLER_H_ diff --git a/content/browser/devtools/protocol/input_handler.cc b/content/browser/devtools/protocol/input_handler.cc new file mode 100644 index 0000000..05cff61 --- /dev/null +++ b/content/browser/devtools/protocol/input_handler.cc @@ -0,0 +1,111 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/input_handler.h" + +#include "base/strings/stringprintf.h" +#include "content/browser/renderer_host/render_view_host_impl.h" +#include "third_party/WebKit/public/web/WebInputEvent.h" + +namespace content { +namespace devtools { +namespace input { + +typedef DevToolsProtocolClient::Response Response; + +InputHandler::InputHandler() + : host_(NULL) { +} + +InputHandler::~InputHandler() { +} + +void InputHandler::SetRenderViewHost(RenderViewHostImpl* host) { + host_ = host; +} + +Response InputHandler::EmulateTouchFromMouseEvent(const std::string& type, + int x, + int y, + double timestamp, + const std::string& button, + double* delta_x, + double* delta_y, + int* modifiers, + int* click_count) { + blink::WebMouseWheelEvent wheel_event; + blink::WebMouseEvent mouse_event; + blink::WebMouseEvent* event = &mouse_event; + + if (type == emulate_touch_from_mouse_event::kTypeMousePressed) { + event->type = blink::WebInputEvent::MouseDown; + } else if (type == emulate_touch_from_mouse_event::kTypeMouseReleased) { + event->type = blink::WebInputEvent::MouseUp; + } else if (type == emulate_touch_from_mouse_event::kTypeMouseMoved) { + event->type = blink::WebInputEvent::MouseMove; + } else if (type == emulate_touch_from_mouse_event::kTypeMouseWheel) { + if (!delta_x || !delta_y) { + return Response::InvalidParams( + "'deltaX' and 'deltaY' are expected for mouseWheel event"); + } + wheel_event.deltaX = static_cast<float>(*delta_x); + wheel_event.deltaY = static_cast<float>(*delta_y); + event = &wheel_event; + event->type = blink::WebInputEvent::MouseWheel; + } else { + return Response::InvalidParams( + base::StringPrintf("Unexpected event type '%s'", type.c_str())); + } + + if (modifiers) { + if (*modifiers & 1) + event->modifiers |= blink::WebInputEvent::AltKey; + if (*modifiers & 2) + event->modifiers |= blink::WebInputEvent::ControlKey; + if (*modifiers & 4) + event->modifiers |= blink::WebInputEvent::MetaKey; + if (*modifiers & 8) + event->modifiers |= blink::WebInputEvent::ShiftKey; + } + + event->timeStampSeconds = timestamp; + event->x = x; + event->y = y; + event->windowX = x; + event->windowY = y; + event->globalX = x; + event->globalY = y; + + if (click_count) + event->clickCount = *click_count; + + if (button == emulate_touch_from_mouse_event::kButtonNone) { + event->button = blink::WebMouseEvent::ButtonNone; + } else if (button == emulate_touch_from_mouse_event::kButtonLeft) { + event->button = blink::WebMouseEvent::ButtonLeft; + event->modifiers |= blink::WebInputEvent::LeftButtonDown; + } else if (button == emulate_touch_from_mouse_event::kButtonMiddle) { + event->button = blink::WebMouseEvent::ButtonMiddle; + event->modifiers |= blink::WebInputEvent::MiddleButtonDown; + } else if (button == emulate_touch_from_mouse_event::kButtonRight) { + event->button = blink::WebMouseEvent::ButtonRight; + event->modifiers |= blink::WebInputEvent::RightButtonDown; + } else { + return Response::InvalidParams( + base::StringPrintf("Unexpected mouse button '%s'", button.c_str())); + } + + if (!host_) + return Response::ServerError("Could not connect to view"); + + if (event->type == blink::WebInputEvent::MouseWheel) + host_->ForwardWheelEvent(wheel_event); + else + host_->ForwardMouseEvent(mouse_event); + return Response::OK(); +} + +} // namespace input +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/input_handler.h b/content/browser/devtools/protocol/input_handler.h new file mode 100644 index 0000000..1a85b2a --- /dev/null +++ b/content/browser/devtools/protocol/input_handler.h @@ -0,0 +1,46 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INPUT_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INPUT_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { + +class RenderViewHostImpl; + +namespace devtools { +namespace input { + +class InputHandler { + public: + typedef DevToolsProtocolClient::Response Response; + + InputHandler(); + virtual ~InputHandler(); + + void SetRenderViewHost(RenderViewHostImpl* host); + + Response EmulateTouchFromMouseEvent(const std::string& type, + int x, + int y, + double timestamp, + const std::string& button, + double* delta_x, + double* delta_y, + int* modifiers, + int* click_count); + + private: + RenderViewHostImpl* host_; + + DISALLOW_COPY_AND_ASSIGN(InputHandler); +}; + +} // namespace inpue +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INPUT_HANDLER_H_ diff --git a/content/browser/devtools/protocol/inspector_handler.cc b/content/browser/devtools/protocol/inspector_handler.cc new file mode 100644 index 0000000..4dbbd04 --- /dev/null +++ b/content/browser/devtools/protocol/inspector_handler.cc @@ -0,0 +1,23 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/inspector_handler.h" + +namespace content { +namespace devtools { +namespace inspector { + +InspectorHandler::InspectorHandler() { +} + +InspectorHandler::~InspectorHandler() { +} + +void InspectorHandler::SetClient(scoped_ptr<Client> client) { + client_.swap(client); +} + +} // namespace inspector +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/inspector_handler.h b/content/browser/devtools/protocol/inspector_handler.h new file mode 100644 index 0000000..d6b449e --- /dev/null +++ b/content/browser/devtools/protocol/inspector_handler.h @@ -0,0 +1,31 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INSPECTOR_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INSPECTOR_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { +namespace devtools { +namespace inspector { + +class InspectorHandler { + public: + InspectorHandler(); + virtual ~InspectorHandler(); + + void SetClient(scoped_ptr<Client> client); + + private: + scoped_ptr<Client> client_; + + DISALLOW_COPY_AND_ASSIGN(InspectorHandler); +}; + +} // namespace inspector +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INSPECTOR_HANDLER_H_ diff --git a/content/browser/devtools/protocol/network_handler.cc b/content/browser/devtools/protocol/network_handler.cc new file mode 100644 index 0000000..b47cb49 --- /dev/null +++ b/content/browser/devtools/protocol/network_handler.cc @@ -0,0 +1,40 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/network_handler.h" + +namespace content { +namespace devtools { +namespace network { + +typedef DevToolsProtocolClient::Response Response; + +NetworkHandler::NetworkHandler() { +} + +NetworkHandler::~NetworkHandler() { +} + +Response NetworkHandler::ClearBrowserCache() { + return Response::FallThrough(); +} + +Response NetworkHandler::ClearBrowserCookies() { + return Response::FallThrough(); +} + +Response NetworkHandler::CanEmulateNetworkConditions(bool* result) { + return Response::FallThrough(); +} + +Response NetworkHandler::EmulateNetworkConditions(bool offline, + double latency, + double download_throughput, + double upload_throughput) { + return Response::FallThrough(); +} + +} // namespace dom +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/network_handler.h b/content/browser/devtools/protocol/network_handler.h new file mode 100644 index 0000000..20ba235 --- /dev/null +++ b/content/browser/devtools/protocol/network_handler.h @@ -0,0 +1,38 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_NETWORK_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_NETWORK_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { +namespace devtools { +namespace network { + +class NetworkHandler { + public: + typedef DevToolsProtocolClient::Response Response; + + NetworkHandler(); + virtual ~NetworkHandler(); + + Response ClearBrowserCache(); + Response ClearBrowserCookies(); + Response CanEmulateNetworkConditions(bool* result); + + Response EmulateNetworkConditions(bool offline, + double latency, + double download_throughput, + double upload_throughput); + + private: + DISALLOW_COPY_AND_ASSIGN(NetworkHandler); +}; + +} // namespace network +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_NETWORK_HANDLER_H_ diff --git a/content/browser/devtools/protocol/page_handler.cc b/content/browser/devtools/protocol/page_handler.cc new file mode 100644 index 0000000..33fac54 --- /dev/null +++ b/content/browser/devtools/protocol/page_handler.cc @@ -0,0 +1,131 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/page_handler.h" + +#include "base/base64.h" +#include "content/browser/renderer_host/render_view_host_impl.h" + +namespace content { +namespace devtools { +namespace page { + +typedef DevToolsProtocolClient::Response Response; + +PageHandler::PageHandler() + : weak_factory_(this) { +} + +PageHandler::~PageHandler() { +} + +void PageHandler::SetRenderViewHost(RenderViewHostImpl* host) { + host_ = host; +} + +void PageHandler::SetClient(scoped_ptr<Client> client) { + client_.swap(client); +} + +Response PageHandler::Enable() { + return Response::FallThrough(); +} + +Response PageHandler::Disable() { + return Response::FallThrough(); +} + +Response PageHandler::Reload(const bool* ignoreCache, + const std::string* script_to_evaluate_on_load, + const std::string* script_preprocessor) { + return Response::FallThrough(); +} + +Response PageHandler::Navigate(const std::string& url, + FrameId* frame_id) { + return Response::FallThrough(); +} + +Response PageHandler::GetNavigationHistory( + int* current_index, + std::vector<NavigationEntry>* entries) { + return Response::FallThrough(); +} + +Response PageHandler::NavigateToHistoryEntry(int entry_id) { + return Response::FallThrough(); +} + +Response PageHandler::SetTouchEmulationEnabled(bool enabled) { + return Response::FallThrough(); +} + +scoped_refptr<DevToolsProtocol::Response> PageHandler::CaptureScreenshot( + scoped_refptr<DevToolsProtocol::Command> command) { + if (!host_ || !host_->GetView()) + return command->InternalErrorResponse("Could not connect to view"); + + host_->GetSnapshotFromBrowser( + base::Bind(&PageHandler::ScreenshotCaptured, + weak_factory_.GetWeakPtr(), command)); + return command->AsyncResponsePromise(); +} + +Response PageHandler::CanScreencast(bool* result) { + return Response::FallThrough(); +} + +Response PageHandler::CanEmulate(bool* result) { + return Response::FallThrough(); +} + +Response PageHandler::StartScreencast(const std::string* format, + const int* quality, + const int* max_width, + const int* max_height) { + return Response::FallThrough(); +} + +Response PageHandler::StopScreencast() { + return Response::FallThrough(); +} + +Response PageHandler::HandleJavaScriptDialog(bool accept, + const std::string* prompt_text) { + return Response::FallThrough(); +} + +scoped_refptr<DevToolsProtocol::Response> PageHandler::QueryUsageAndQuota( + const std::string& security_origin, + scoped_refptr<DevToolsProtocol::Command> command) { + return NULL; +} + +Response PageHandler::SetColorPickerEnabled(bool enabled) { + return Response::FallThrough(); +} + +void PageHandler::ScreenshotCaptured( + scoped_refptr<DevToolsProtocol::Command> command, + const unsigned char* png_data, + size_t png_size) { + if (!png_data || !png_size) { + client_->SendInternalErrorResponse(command, + "Unable to capture screenshot"); + return; + } + + std::string base_64_data; + base::Base64Encode( + base::StringPiece(reinterpret_cast<const char*>(png_data), png_size), + &base_64_data); + + CaptureScreenshotResponse response; + response.set_data(base_64_data); + client_->SendCaptureScreenshotResponse(command, response); +} + +} // namespace page +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/page_handler.h b/content/browser/devtools/protocol/page_handler.h new file mode 100644 index 0000000..f63756f2 --- /dev/null +++ b/content/browser/devtools/protocol/page_handler.h @@ -0,0 +1,80 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_PAGE_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_PAGE_HANDLER_H_ + +#include "base/memory/weak_ptr.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { + +class RenderViewHostImpl; + +namespace devtools { +namespace page { + +class PageHandler { + public: + typedef DevToolsProtocolClient::Response Response; + + PageHandler(); + virtual ~PageHandler(); + + void SetRenderViewHost(RenderViewHostImpl* host); + void SetClient(scoped_ptr<Client> client); + + Response Enable(); + Response Disable(); + + Response Reload(const bool* ignoreCache, + const std::string* script_to_evaluate_on_load, + const std::string* script_preprocessor); + + Response Navigate(const std::string& url, FrameId* frame_id); + + Response GetNavigationHistory(int* current_index, + std::vector<NavigationEntry>* entries); + + Response NavigateToHistoryEntry(int entry_id); + Response SetTouchEmulationEnabled(bool enabled); + + scoped_refptr<DevToolsProtocol::Response> CaptureScreenshot( + scoped_refptr<DevToolsProtocol::Command> command); + + Response CanScreencast(bool* result); + Response CanEmulate(bool* result); + + Response StartScreencast(const std::string* format, + const int* quality, + const int* max_width, + const int* max_height); + + Response StopScreencast(); + Response HandleJavaScriptDialog(bool accept, const std::string* prompt_text); + + scoped_refptr<DevToolsProtocol::Response> QueryUsageAndQuota( + const std::string& security_origin, + scoped_refptr<DevToolsProtocol::Command> command); + + Response SetColorPickerEnabled(bool enabled); + + private: + RenderViewHostImpl* host_; + scoped_ptr<Client> client_; + base::WeakPtrFactory<PageHandler> weak_factory_; + + void ScreenshotCaptured( + scoped_refptr<DevToolsProtocol::Command> command, + const unsigned char* png_data, + size_t png_size); + + DISALLOW_COPY_AND_ASSIGN(PageHandler); +}; + +} // namespace page +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_PAGE_HANDLER_H_ diff --git a/content/browser/devtools/protocol/power_handler.cc b/content/browser/devtools/protocol/power_handler.cc new file mode 100644 index 0000000..1265110 --- /dev/null +++ b/content/browser/devtools/protocol/power_handler.cc @@ -0,0 +1,41 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/power_handler.h" + +namespace content { +namespace devtools { +namespace power { + +typedef DevToolsProtocolClient::Response Response; + +PowerHandler::PowerHandler() { +} + +PowerHandler::~PowerHandler() { +} + +void PowerHandler::SetClient(scoped_ptr<Client> client) { + client_.swap(client); +} + +Response PowerHandler::Start() { + return Response::FallThrough(); +} + +Response PowerHandler::End() { + return Response::FallThrough(); +} + +Response PowerHandler::CanProfilePower(bool* result) { + return Response::FallThrough(); +} + +Response PowerHandler::GetAccuracyLevel(std::string* result) { + return Response::FallThrough(); +} + +} // namespace power +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/power_handler.h b/content/browser/devtools/protocol/power_handler.h new file mode 100644 index 0000000..00ac4ee --- /dev/null +++ b/content/browser/devtools/protocol/power_handler.h @@ -0,0 +1,38 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_POWER_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_POWER_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { +namespace devtools { +namespace power { + +class PowerHandler { + public: + typedef DevToolsProtocolClient::Response Response; + + PowerHandler(); + virtual ~PowerHandler(); + + void SetClient(scoped_ptr<Client> client); + + Response Start(); + Response End(); + Response CanProfilePower(bool* result); + Response GetAccuracyLevel(std::string* result); + + private: + scoped_ptr<Client> client_; + + DISALLOW_COPY_AND_ASSIGN(PowerHandler); +}; + +} // namespace power +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_POWER_HANDLER_H_ diff --git a/content/browser/devtools/protocol/tracing_handler.cc b/content/browser/devtools/protocol/tracing_handler.cc new file mode 100644 index 0000000..e3da76c --- /dev/null +++ b/content/browser/devtools/protocol/tracing_handler.cc @@ -0,0 +1,40 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/tracing_handler.h" + +namespace content { +namespace devtools { +namespace tracing { + +typedef DevToolsProtocolClient::Response Response; + +TracingHandler::TracingHandler() { +} + +TracingHandler::~TracingHandler() { +} + +void TracingHandler::SetClient(scoped_ptr<Client> client) { + client_.swap(client); +} + +Response TracingHandler::Start(const std::string& categories, + const std::string& options, + const double* buffer_usage_reporting_interval) { + return Response::FallThrough(); +} + +Response TracingHandler::End() { + return Response::FallThrough(); +} + +scoped_refptr<DevToolsProtocol::Response> TracingHandler::GetCategories( + scoped_refptr<DevToolsProtocol::Command> command) { + return NULL; +} + +} // namespace tracing +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/tracing_handler.h b/content/browser/devtools/protocol/tracing_handler.h new file mode 100644 index 0000000..2ec9508 --- /dev/null +++ b/content/browser/devtools/protocol/tracing_handler.h @@ -0,0 +1,42 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_TRACING_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_TRACING_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { +namespace devtools { +namespace tracing { + +class TracingHandler { + public: + typedef DevToolsProtocolClient::Response Response; + + TracingHandler(); + virtual ~TracingHandler(); + + void SetClient(scoped_ptr<Client> client); + + Response Start(const std::string& categories, + const std::string& options, + const double* buffer_usage_reporting_interval); + + Response End(); + + scoped_refptr<DevToolsProtocol::Response> GetCategories( + scoped_refptr<DevToolsProtocol::Command> command); + + private: + scoped_ptr<Client> client_; + + DISALLOW_COPY_AND_ASSIGN(TracingHandler); +}; + +} // namespace tracing +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_TRACING_HANDLER_H_ diff --git a/content/browser/devtools/protocol/worker_handler.cc b/content/browser/devtools/protocol/worker_handler.cc new file mode 100644 index 0000000..fd8fc09 --- /dev/null +++ b/content/browser/devtools/protocol/worker_handler.cc @@ -0,0 +1,30 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/browser/devtools/protocol/worker_handler.h" + +namespace content { +namespace devtools { +namespace worker { + +typedef DevToolsProtocolClient::Response Response; +typedef DevToolsProtocolClient::ResponseStatus ResponseStatus; + +WorkerHandler::WorkerHandler() { +} + +WorkerHandler::~WorkerHandler() { +} + +void WorkerHandler::SetClient(scoped_ptr<Client> client) { + client_.swap(client); +} + +Response WorkerHandler::DisconnectFromWorker(int worker_id) { + return Response::FallThrough(); +} + +} // namespace worker +} // namespace devtools +} // namespace content diff --git a/content/browser/devtools/protocol/worker_handler.h b/content/browser/devtools/protocol/worker_handler.h new file mode 100644 index 0000000..1c1faaf --- /dev/null +++ b/content/browser/devtools/protocol/worker_handler.h @@ -0,0 +1,35 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_WORKER_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_WORKER_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" + +namespace content { +namespace devtools { +namespace worker { + +class WorkerHandler { + public: + typedef DevToolsProtocolClient::Response Response; + + WorkerHandler(); + virtual ~WorkerHandler(); + + void SetClient(scoped_ptr<Client> client); + + Response DisconnectFromWorker(int worker_id); + + private: + scoped_ptr<Client> client_; + + DISALLOW_COPY_AND_ASSIGN(WorkerHandler); +}; + +} // namespace worker +} // namespace devtools +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_WORKER_HANDLER_H_ |