Skip to content

GitLab

T
tangled
Commit e3b6a1e8 authored by zmo's avatar zmo Committed by Commit bot
Browse files
Options

Revert of DevTools: Protocol handler generator for content (patchset #30... 

Revert of DevTools: Protocol handler generator for content (patchset #30 id:580001 of https://codereview.chromium.org/508973003/)

Reason for revert:
This causes a lot of layout tests to timeout on Linux ASAN bot in webkit waterfall.

Original issue's description:
> DevTools: Protocol handler generator for content
>
> BUG=405566
>
> Committed: https://crrev.com/4b0b62979ddd96b65064364eb669ec9dda7e5e5e
> Cr-Commit-Position: refs/heads/master@{#296723}

TBR=jochen@chromium.org,dgozman@chromium.org,pfeldman@chromium.org,yurys@chromium.org,vkuzkokov@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=405566

Review URL: https://codereview.chromium.org/612523004

Cr-Commit-Position: refs/heads/master@{#297035}
parent fe4c12d6
Hide whitespace changes
Inline Side-by-side
Showing with 186 additions and 1842 deletions
content/browser/BUILD.gn
View file @ e3b6a1e8
......@@ -84,8 +84,6 @@ source_set("browser") {
"$root_gen_dir/ui/resources/grit/webui_resources_map.cc",
"$root_gen_dir/content/browser/devtools/devtools_protocol_constants.cc",
"$root_gen_dir/content/browser/devtools/devtools_protocol_constants.h",
"$root_gen_dir/content/browser/devtools/protocol/devtools_protocol_handler_impl.cc",
"$root_gen_dir/content/browser/devtools/protocol/devtools_protocol_handler_impl.h",
], ".")
# Non-iOS deps.
......
content/browser/devtools/BUILD.gn
View file @ e3b6a1e8
......@@ -9,7 +9,6 @@ group("resources") {
deps = [
":devtools_resources",
":devtools_protocol_constants",
":devtools_protocol_handler",
]
}
......@@ -57,31 +56,7 @@ action("gen_devtools_protocol_constants") {
]
}
action("gen_devtools_protocol_handler") {
visibility = [ ":devtools_protocol_handler" ]
script = "//content/browser/devtools/protocol/" +
"devtools_protocol_handler_generator.py"
blink_protocol = "//third_party/WebKit/Source/devtools/protocol.json"
inputs = [ blink_protocol ]
outputs = [
"$target_gen_dir/protocol/devtools_protocol_handler_impl.cc",
"$target_gen_dir/protocol/devtools_protocol_handler_impl.h",
]
args = [
rebase_path(blink_protocol, root_build_dir),
] + rebase_path(outputs, root_build_dir)
}
source_set("devtools_protocol_constants") {
visibility = [ ":resources" ]
sources = get_target_outputs(":gen_devtools_protocol_constants")
}
source_set("devtools_protocol_handler") {
visibility = [ ":resources" ]
sources = get_target_outputs(":gen_devtools_protocol_handler")
}
content/browser/devtools/devtools.gyp deleted 100644 → 0
View file @ fe4c12d6
# 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.
{
'targets': [
{
'target_name': 'devtools_protocol_handler',
'type': 'none',
'actions': [
{
'action_name': 'devtools_protocol_handler',
'variables': {
'blink_protocol': '../../../third_party/WebKit/Source/devtools/protocol.json',
'generator': 'protocol/devtools_protocol_handler_generator.py',
'output_cc': '<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_handler_impl.cc',
'output_h': '<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_handler_impl.h',
},
'inputs': [
'<(blink_protocol)',
'<(generator)',
],
'outputs': [
'<(output_cc)',
'<(output_h)',
],
'action':[
'python',
'<(generator)',
'<(blink_protocol)',
'<(output_cc)',
'<(output_h)',
],
'message': 'Generating DevTools protocol browser-side handlers from <(blink_protocol)'
},
],
'direct_dependent_settings': {
'include_dirs': [
'<(SHARED_INTERMEDIATE_DIR)',
]
},
},
],
}
content/browser/devtools/protocol/devtools_protocol_client.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/devtools_protocol_client.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/devtools_protocol_handler_generator.py deleted 100755 → 0
View file @ fe4c12d6
#!/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()
content/browser/devtools/protocol/dom_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/dom_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/input_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/input_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/inspector_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/inspector_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/network_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/network_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/page_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/page_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/power_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/power_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/tracing_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/tracing_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/protocol/worker_handler.cc deleted 100644 → 0
View file @ fe4c12d6
// 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
content/browser/devtools/protocol/worker_handler.h deleted 100644 → 0
View file @ fe4c12d6
// 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_
content/browser/devtools/render_view_devtools_agent_host.cc
View file @ e3b6a1e8
......@@ -13,7 +13,6 @@
#include "content/browser/devtools/devtools_protocol.h"
#include "content/browser/devtools/devtools_protocol_constants.h"
#include "content/browser/devtools/devtools_tracing_handler.h"
#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
#include "content/browser/devtools/renderer_overrides_handler.h"
#include "content/browser/renderer_host/render_process_host_impl.h"
#include "content/browser/renderer_host/render_view_host_impl.h"
......@@ -110,21 +109,15 @@ void RenderViewDevToolsAgentHost::OnCancelPendingNavigation(
RenderViewDevToolsAgentHost::RenderViewDevToolsAgentHost(RenderViewHost* rvh)
: render_view_host_(NULL),
input_handler_(new devtools::input::InputHandler()),
page_handler_(new devtools::page::PageHandler()),
handler_impl_(new DevToolsProtocolHandlerImpl()),
overrides_handler_(new RendererOverridesHandler()),
tracing_handler_(
new DevToolsTracingHandler(DevToolsTracingHandler::Renderer)),
power_handler_(new DevToolsPowerHandler()),
reattaching_(false) {
handler_impl_->SetInputHandler(input_handler_.get());
handler_impl_->SetPageHandler(page_handler_.get());
SetRenderViewHost(rvh);
DevToolsProtocol::Notifier notifier(base::Bind(
&RenderViewDevToolsAgentHost::OnDispatchOnInspectorFrontend,
base::Unretained(this)));
handler_impl_->SetNotifier(notifier);
overrides_handler_->SetNotifier(notifier);
tracing_handler_->SetNotifier(notifier);
power_handler_->SetNotifier(notifier);
......@@ -163,8 +156,6 @@ void RenderViewDevToolsAgentHost::DispatchProtocolMessage(
overridden_response = tracing_handler_->HandleCommand(command);
if (!overridden_response.get())
overridden_response = power_handler_->HandleCommand(command);
if (!overridden_response.get())
overridden_response = handler_impl_->HandleCommand(command);
if (overridden_response.get()) {
if (!overridden_response->is_async_promise())
OnDispatchOnInspectorFrontend(overridden_response->Serialize());
......@@ -363,8 +354,6 @@ void RenderViewDevToolsAgentHost::SetRenderViewHost(RenderViewHost* rvh) {
WebContentsObserver::Observe(WebContents::FromRenderViewHost(rvh));
overrides_handler_->SetRenderViewHost(render_view_host_);
input_handler_->SetRenderViewHost(render_view_host_);
page_handler_->SetRenderViewHost(render_view_host_);
registrar_.Add(
this,
......@@ -380,8 +369,6 @@ void RenderViewDevToolsAgentHost::ClearRenderViewHost() {
content::Source<RenderWidgetHost>(render_view_host_));
render_view_host_ = NULL;
overrides_handler_->ClearRenderViewHost();
input_handler_->SetRenderViewHost(NULL);
page_handler_->SetRenderViewHost(NULL);
}
void RenderViewDevToolsAgentHost::DisconnectWebContents() {
......
content/browser/devtools/render_view_devtools_agent_host.h
View file @ e3b6a1e8
......@@ -11,8 +11,6 @@
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "content/browser/devtools/ipc_devtools_agent_host.h"
#include "content/browser/devtools/protocol/input_handler.h"
#include "content/browser/devtools/protocol/page_handler.h"
#include "content/common/content_export.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
......@@ -25,7 +23,6 @@ class CompositorFrameMetadata;
namespace content {
class DevToolsPowerHandler;
class DevToolsProtocolHandlerImpl;
class DevToolsTracingHandler;
class RendererOverridesHandler;
class RenderViewHost;
......@@ -107,9 +104,6 @@ class CONTENT_EXPORT RenderViewDevToolsAgentHost
void InnerClientDetachedFromRenderer();
RenderViewHostImpl* render_view_host_;
scoped_ptr<devtools::input::InputHandler> input_handler_;
scoped_ptr<devtools::page::PageHandler> page_handler_;
scoped_ptr<DevToolsProtocolHandlerImpl> handler_impl_;
scoped_ptr<RendererOverridesHandler> overrides_handler_;
scoped_ptr<DevToolsTracingHandler> tracing_handler_;
scoped_ptr<DevToolsPowerHandler> power_handler_;
......
content/browser/devtools/renderer_overrides_handler.cc
View file @ e3b6a1e8
......@@ -134,6 +134,11 @@ RendererOverridesHandler::RendererOverridesHandler()
base::Bind(
&RendererOverridesHandler::PageNavigateToHistoryEntry,
base::Unretained(this)));
RegisterCommandHandler(
devtools::Page::captureScreenshot::kName,
base::Bind(
&RendererOverridesHandler::PageCaptureScreenshot,
base::Unretained(this)));
RegisterCommandHandler(
devtools::Page::setTouchEmulationEnabled::kName,
base::Bind(
......@@ -169,6 +174,11 @@ RendererOverridesHandler::RendererOverridesHandler()
base::Bind(
&RendererOverridesHandler::PageSetColorPickerEnabled,
base::Unretained(this)));
RegisterCommandHandler(
devtools::Input::emulateTouchFromMouseEvent::kName,
base::Bind(
&RendererOverridesHandler::InputEmulateTouchFromMouseEvent,
base::Unretained(this)));
mouse_event_callback_ = base::Bind(
&RendererOverridesHandler::HandleMouseEvent,
base::Unretained(this));
......@@ -507,6 +517,40 @@ RendererOverridesHandler::PageNavigateToHistoryEntry(
return command->InternalErrorResponse("No WebContents to navigate");
}
scoped_refptr<DevToolsProtocol::Response>
RendererOverridesHandler::PageCaptureScreenshot(
scoped_refptr<DevToolsProtocol::Command> command) {
if (!host_ || !host_->GetView())
return command->InternalErrorResponse("Could not connect to view");
host_->GetSnapshotFromBrowser(
base::Bind(&RendererOverridesHandler::ScreenshotCaptured,
weak_factory_.GetWeakPtr(), command));
return command->AsyncResponsePromise();
}
void RendererOverridesHandler::ScreenshotCaptured(
scoped_refptr<DevToolsProtocol::Command> command,
const unsigned char* png_data,
size_t png_size) {
if (!png_data || !png_size) {
SendAsyncResponse(
command->InternalErrorResponse("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);
base::DictionaryValue* response = new base::DictionaryValue();
response->SetString(devtools::Page::screencastFrame::kParamData,
base_64_data);
SendAsyncResponse(command->SuccessResponse(response));
}
scoped_refptr<DevToolsProtocol::Response>
RendererOverridesHandler::PageSetTouchEmulationEnabled(
scoped_refptr<DevToolsProtocol::Command> command) {
......@@ -1147,6 +1191,137 @@ void RendererOverridesHandler::UpdateColorPickerCursor() {
host_->SetCursor(cursor);
}
// Input agent handlers ------------------------------------------------------
scoped_refptr<DevToolsProtocol::Response>
RendererOverridesHandler::InputEmulateTouchFromMouseEvent(
scoped_refptr<DevToolsProtocol::Command> command) {
if (!screencast_command_.get())
return command->InternalErrorResponse("Screencast should be turned on");
base::DictionaryValue* params = command->params();
if (!params)
return command->NoSuchMethodErrorResponse();
std::string type;
if (!params->GetString(
devtools::Input::emulateTouchFromMouseEvent::kParamType,
&type)) {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamType);
}
blink::WebMouseWheelEvent wheel_event;
blink::WebMouseEvent mouse_event;
blink::WebMouseEvent* event = &mouse_event;
if (type ==
devtools::Input::emulateTouchFromMouseEvent::Type::kEnumMousePressed) {
event->type = WebInputEvent::MouseDown;
} else if (type ==
devtools::Input::emulateTouchFromMouseEvent::Type::kEnumMouseReleased) {
event->type = WebInputEvent::MouseUp;
} else if (type ==
devtools::Input::emulateTouchFromMouseEvent::Type::kEnumMouseMoved) {
event->type = WebInputEvent::MouseMove;
} else if (type ==
devtools::Input::emulateTouchFromMouseEvent::Type::kEnumMouseWheel) {
double deltaX = 0;
double deltaY = 0;
if (!params->GetDouble(
devtools::Input::emulateTouchFromMouseEvent::kParamDeltaX,
&deltaX)) {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamDeltaX);
}
if (!params->GetDouble(
devtools::Input::emulateTouchFromMouseEvent::kParamDeltaY,
&deltaY)) {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamDeltaY);
}
wheel_event.deltaX = static_cast<float>(deltaX);
wheel_event.deltaY = static_cast<float>(deltaY);
event = &wheel_event;
event->type = WebInputEvent::MouseWheel;
} else {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamType);
}
int modifiers = 0;
if (params->GetInteger(
devtools::Input::emulateTouchFromMouseEvent::kParamModifiers,
&modifiers)) {
if (modifiers & 1)
event->modifiers |= WebInputEvent::AltKey;
if (modifiers & 2)
event->modifiers |= WebInputEvent::ControlKey;
if (modifiers & 4)
event->modifiers |= WebInputEvent::MetaKey;
if (modifiers & 8)
event->modifiers |= WebInputEvent::ShiftKey;
}
params->GetDouble(
devtools::Input::emulateTouchFromMouseEvent::kParamTimestamp,
&event->timeStampSeconds);
if (!params->GetInteger(devtools::Input::emulateTouchFromMouseEvent::kParamX,
&event->x)) {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamX);
}
if (!params->GetInteger(devtools::Input::emulateTouchFromMouseEvent::kParamY,
&event->y)) {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamY);
}
event->windowX = event->x;
event->windowY = event->y;
event->globalX = event->x;
event->globalY = event->y;
params->GetInteger(
devtools::Input::emulateTouchFromMouseEvent::kParamClickCount,
&event->clickCount);
std::string button;
if (!params->GetString(
devtools::Input::emulateTouchFromMouseEvent::kParamButton,
&button)) {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamButton);
}
if (button == "none") {
event->button = WebMouseEvent::ButtonNone;
} else if (button == "left") {
event->button = WebMouseEvent::ButtonLeft;
event->modifiers |= WebInputEvent::LeftButtonDown;
} else if (button == "middle") {
event->button = WebMouseEvent::ButtonMiddle;
event->modifiers |= WebInputEvent::MiddleButtonDown;
} else if (button == "right") {
event->button = WebMouseEvent::ButtonRight;
event->modifiers |= WebInputEvent::RightButtonDown;
} else {
return command->InvalidParamResponse(
devtools::Input::emulateTouchFromMouseEvent::kParamButton);
}
if (!host_)
return command->InternalErrorResponse("Could not connect to view");
if (event->type == WebInputEvent::MouseWheel)
host_->ForwardWheelEvent(wheel_event);
else
host_->ForwardMouseEvent(mouse_event);
return command->SuccessResponse(NULL);
}
void RendererOverridesHandler::UpdateTouchEventEmulationState() {
if (!host_)
return;
......
content/browser/devtools/renderer_overrides_handler.h
View file @ e3b6a1e8
......@@ -82,6 +82,8 @@ class CONTENT_EXPORT RendererOverridesHandler
scoped_refptr<DevToolsProtocol::Command> command);
scoped_refptr<DevToolsProtocol::Response> PageSetTouchEmulationEnabled(
scoped_refptr<DevToolsProtocol::Command> command);
scoped_refptr<DevToolsProtocol::Response> PageCaptureScreenshot(
scoped_refptr<DevToolsProtocol::Command> command);
scoped_refptr<DevToolsProtocol::Response> PageCanEmulate(
scoped_refptr<DevToolsProtocol::Command> command);
scoped_refptr<DevToolsProtocol::Response> PageCanScreencast(
......@@ -95,6 +97,11 @@ class CONTENT_EXPORT RendererOverridesHandler
scoped_refptr<DevToolsProtocol::Response> PageSetColorPickerEnabled(
scoped_refptr<DevToolsProtocol::Command>);
void ScreenshotCaptured(
scoped_refptr<DevToolsProtocol::Command> command,
const unsigned char* png_data,
size_t png_size);
void ScreencastFrameCaptured(
const std::string& format,
int quality,
......@@ -114,6 +121,10 @@ class CONTENT_EXPORT RendererOverridesHandler
bool HandleMouseEvent(const blink::WebMouseEvent& event);
void UpdateColorPickerCursor();
// Input domain.
scoped_refptr<DevToolsProtocol::Response> InputEmulateTouchFromMouseEvent(
scoped_refptr<DevToolsProtocol::Command> command);
void UpdateTouchEventEmulationState();
RenderViewHostImpl* host_;
......
content/content_browser.gypi
View file @ e3b6a1e8
......@@ -457,24 +457,6 @@
'browser/devtools/embedded_worker_devtools_agent_host.h',
'browser/devtools/embedded_worker_devtools_manager.cc',
'browser/devtools/embedded_worker_devtools_manager.h',
'browser/devtools/protocol/devtools_protocol_client.cc',
'browser/devtools/protocol/devtools_protocol_client.h',
'browser/devtools/protocol/dom_handler.cc',
'browser/devtools/protocol/dom_handler.h',
'browser/devtools/protocol/input_handler.cc',
'browser/devtools/protocol/input_handler.h',
'browser/devtools/protocol/inspector_handler.cc',
'browser/devtools/protocol/inspector_handler.h',
'browser/devtools/protocol/network_handler.cc',
'browser/devtools/protocol/network_handler.h',
'browser/devtools/protocol/page_handler.cc',
'browser/devtools/protocol/page_handler.h',
'browser/devtools/protocol/power_handler.cc',
'browser/devtools/protocol/power_handler.h',
'browser/devtools/protocol/tracing_handler.cc',
'browser/devtools/protocol/tracing_handler.h',
'browser/devtools/protocol/worker_handler.cc',
'browser/devtools/protocol/worker_handler.h',
'browser/devtools/render_view_devtools_agent_host.cc',
'browser/devtools/render_view_devtools_agent_host.h',
'browser/devtools/renderer_overrides_handler.cc',
......@@ -1393,9 +1375,6 @@
# These files are generated by devtools_protocol_constants_generator.py.
'<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/devtools_protocol_constants.cc',
'<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/devtools_protocol_constants.h',
# These files are generated by devtools_protocol_handler_generator.py.
'<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_handler_impl.cc',
'<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_handler_impl.h',
],
'android_browser_sources': [
'browser/android/java/gin_java_bound_object.cc',
......@@ -1629,7 +1608,6 @@
'app/resources/content_resources.gyp:content_resources',
'app/strings/content_strings.gyp:content_strings',
'browser/devtools/devtools_resources.gyp:devtools_resources',
'browser/devtools/devtools.gyp:devtools_protocol_handler',
'content_common_mojo_bindings',
'../cc/cc.gyp:cc',
'../cc/cc.gyp:cc_surfaces',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment