DevTools: Protocol handler generator for content

BUG=405566

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

Cr-Commit-Position: refs/heads/master@{#296723}

27 files changed, 1842 insertions, 186 deletions

diff --git a/content/browser/BUILD.gn b/content/browser/BUILD.gn
index 8819aa3..726e98c 100644
--- a/content/browser/BUILD.gn
+++ b/content/browser/BUILD.gn
@@ -84,6 +84,8 @@ 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.
diff --git a/content/browser/devtools/BUILD.gn b/content/browser/devtools/BUILD.gn
index bc2b60d..75777316 100644
--- a/content/browser/devtools/BUILD.gn
+++ b/content/browser/devtools/BUILD.gn
@@ -9,6 +9,7 @@ group("resources") {
   deps = [
     ":devtools_resources",
     ":devtools_protocol_constants",
+    ":devtools_protocol_handler",
   ]
 }
 
@@ -56,7 +57,31 @@ 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")
+}
diff --git a/content/browser/devtools/devtools.gyp b/content/browser/devtools/devtools.gyp
new file mode 100644
index 0000000..a67eca8
--- /dev/null
+++ b/content/browser/devtools/devtools.gyp
@@ -0,0 +1,44 @@
+# 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)',
+        ]
+      },
+    },
+  ],
+}
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_
diff --git a/content/browser/devtools/render_view_devtools_agent_host.cc b/content/browser/devtools/render_view_devtools_agent_host.cc
index 7045b37..3da9a23 100644
--- a/content/browser/devtools/render_view_devtools_agent_host.cc
+++ b/content/browser/devtools/render_view_devtools_agent_host.cc
@@ -13,6 +13,7 @@
 #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"
@@ -109,15 +110,21 @@ 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);
@@ -156,6 +163,8 @@ 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());
@@ -354,6 +363,8 @@ 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,
@@ -369,6 +380,8 @@ 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() {
diff --git a/content/browser/devtools/render_view_devtools_agent_host.h b/content/browser/devtools/render_view_devtools_agent_host.h
index 7b35388..089933c 100644
--- a/content/browser/devtools/render_view_devtools_agent_host.h
+++ b/content/browser/devtools/render_view_devtools_agent_host.h
@@ -11,6 +11,8 @@
 #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"
@@ -23,6 +25,7 @@ class CompositorFrameMetadata;
 namespace content {
 
 class DevToolsPowerHandler;
+class DevToolsProtocolHandlerImpl;
 class DevToolsTracingHandler;
 class RendererOverridesHandler;
 class RenderViewHost;
@@ -104,6 +107,9 @@ 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_;
diff --git a/content/browser/devtools/renderer_overrides_handler.cc b/content/browser/devtools/renderer_overrides_handler.cc
index 3c126ff..e0b45da 100644
--- a/content/browser/devtools/renderer_overrides_handler.cc
+++ b/content/browser/devtools/renderer_overrides_handler.cc
@@ -135,11 +135,6 @@ RendererOverridesHandler::RendererOverridesHandler()
           &RendererOverridesHandler::PageNavigateToHistoryEntry,
           base::Unretained(this)));
   RegisterCommandHandler(
-      devtools::Page::captureScreenshot::kName,
-      base::Bind(
-          &RendererOverridesHandler::PageCaptureScreenshot,
-          base::Unretained(this)));
-  RegisterCommandHandler(
       devtools::Page::setTouchEmulationEnabled::kName,
       base::Bind(
           &RendererOverridesHandler::PageSetTouchEmulationEnabled,
@@ -174,11 +169,6 @@ 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));
@@ -518,40 +508,6 @@ RendererOverridesHandler::PageNavigateToHistoryEntry(
 }
 
 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) {
   base::DictionaryValue* params = command->params();
@@ -1191,137 +1147,6 @@ 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;
diff --git a/content/browser/devtools/renderer_overrides_handler.h b/content/browser/devtools/renderer_overrides_handler.h
index b8bf255..988a7c2 100644
--- a/content/browser/devtools/renderer_overrides_handler.h
+++ b/content/browser/devtools/renderer_overrides_handler.h
@@ -82,8 +82,6 @@ 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(
@@ -97,11 +95,6 @@ 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,
@@ -121,10 +114,6 @@ 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_;
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index 49cfd02..153d7ad 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -457,6 +457,24 @@
       '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',
@@ -1375,6 +1393,9 @@
       # 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',
@@ -1608,6 +1629,7 @@
         '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',