[DevTools] Removed DevToolsProtocol in content

BUG=405566

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

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

33 files changed, 495 insertions, 886 deletions

diff --git a/content/browser/BUILD.gn b/content/browser/BUILD.gn
index ade4a78..5942d29 100644
--- a/content/browser/BUILD.gn
+++ b/content/browser/BUILD.gn
@@ -86,8 +86,8 @@ source_set("browser") {
               "$root_gen_dir/webkit/grit/devtools_resources_map.h",
               "$root_gen_dir/content/browser/tracing/grit/tracing_resources.h",
               "$root_gen_dir/ui/resources/grit/webui_resources_map.cc",
-              "$root_gen_dir/content/browser/devtools/protocol/devtools_protocol_handler_impl.cc",
-              "$root_gen_dir/content/browser/devtools/protocol/devtools_protocol_handler_impl.h",
+              "$root_gen_dir/content/browser/devtools/protocol/devtools_protocol_dispatcher.cc",
+              "$root_gen_dir/content/browser/devtools/protocol/devtools_protocol_dispatcher.h",
             ],
             ".")
 
diff --git a/content/browser/devtools/BUILD.gn b/content/browser/devtools/BUILD.gn
index 286de5e..975e7bb 100644
--- a/content/browser/devtools/BUILD.gn
+++ b/content/browser/devtools/BUILD.gn
@@ -49,8 +49,8 @@ action("gen_devtools_protocol_handler") {
   ]
 
   outputs = [
-    "$target_gen_dir/protocol/devtools_protocol_handler_impl.cc",
-    "$target_gen_dir/protocol/devtools_protocol_handler_impl.h",
+    "$target_gen_dir/protocol/devtools_protocol_dispatcher.cc",
+    "$target_gen_dir/protocol/devtools_protocol_dispatcher.h",
   ]
 
   args =
diff --git a/content/browser/devtools/devtools.gyp b/content/browser/devtools/devtools.gyp
index 8957d72..9aaaf25 100644
--- a/content/browser/devtools/devtools.gyp
+++ b/content/browser/devtools/devtools.gyp
@@ -14,8 +14,8 @@
             'blink_protocol': '../../../third_party/WebKit/Source/devtools/protocol.json',
             'browser_protocol': 'browser_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',
+            'output_cc': '<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_dispatcher.cc',
+            'output_h': '<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_dispatcher.h',
           },
           'inputs': [
             '<(blink_protocol)',
diff --git a/content/browser/devtools/devtools_http_handler_impl.cc b/content/browser/devtools/devtools_http_handler_impl.cc
index 3f3df91..5bd8887 100644
--- a/content/browser/devtools/devtools_http_handler_impl.cc
+++ b/content/browser/devtools/devtools_http_handler_impl.cc
@@ -16,8 +16,7 @@
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "content/browser/devtools/devtools_manager.h"
-#include "content/browser/devtools/devtools_protocol.h"
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/browser/devtools/protocol/system_info_handler.h"
 #include "content/browser/devtools/protocol/tethering_handler.h"
 #include "content/browser/devtools/protocol/tracing_handler.h"
@@ -408,32 +407,23 @@ class BrowserTarget {
             delegate, message_loop->message_loop_proxy())),
         tracing_handler_(new devtools::tracing::TracingHandler(
             devtools::tracing::TracingHandler::Browser)),
-        protocol_handler_(new DevToolsProtocolHandlerImpl()) {
-    protocol_handler_->SetNotifier(
-        base::Bind(&BrowserTarget::Respond, base::Unretained(this)));
-    protocol_handler_->SetSystemInfoHandler(system_info_handler_.get());
-    protocol_handler_->SetTetheringHandler(tethering_handler_.get());
-    protocol_handler_->SetTracingHandler(tracing_handler_.get());
+        protocol_handler_(new DevToolsProtocolHandler(
+            true /* handle_generic_errors */,
+            base::Bind(&BrowserTarget::Respond, base::Unretained(this)))) {
+    DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
+    dispatcher->SetSystemInfoHandler(system_info_handler_.get());
+    dispatcher->SetTetheringHandler(tethering_handler_.get());
+    dispatcher->SetTracingHandler(tracing_handler_.get());
   }
 
   void HandleMessage(const std::string& message) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     std::string error_response;
-    scoped_refptr<DevToolsProtocol::Command> command =
-        DevToolsProtocol::ParseCommand(message, &error_response);
-    if (!command.get()) {
-      Respond(error_response);
-      return;
-    }
-
-    scoped_refptr<DevToolsProtocol::Response> response =
-        protocol_handler_->HandleCommand(command);
-
-    if (response.get()) {
-      if (!response->is_async_promise())
-        Respond(response->Serialize());
-    } else {
-      Respond(command->NoSuchMethodErrorResponse()->Serialize());
+    scoped_ptr<base::DictionaryValue> command =
+        protocol_handler_->ParseCommand(message);
+    if (command) {
+      bool result = protocol_handler_->HandleCommand(command.Pass());
+      DCHECK(result);
     }
   }
 
@@ -454,7 +444,7 @@ class BrowserTarget {
   scoped_ptr<devtools::system_info::SystemInfoHandler> system_info_handler_;
   scoped_ptr<devtools::tethering::TetheringHandler> tethering_handler_;
   scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
-  scoped_ptr<DevToolsProtocolHandlerImpl> protocol_handler_;
+  scoped_ptr<DevToolsProtocolHandler> protocol_handler_;
 };
 
 }  // namespace
diff --git a/content/browser/devtools/devtools_protocol.cc b/content/browser/devtools/devtools_protocol.cc
deleted file mode 100644
index e3d5314..0000000
--- a/content/browser/devtools/devtools_protocol.cc
+++ /dev/null
@@ -1,331 +0,0 @@
-// Copyright (c) 2013 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/devtools_protocol.h"
-
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/strings/stringprintf.h"
-
-namespace content {
-
-namespace {
-
-const char kIdParam[] = "id";
-const char kMethodParam[] = "method";
-const char kParamsParam[] = "params";
-const char kResultParam[] = "result";
-const char kErrorParam[] = "error";
-const char kErrorCodeParam[] = "code";
-const char kErrorMessageParam[] = "message";
-const int kNoId = -1;
-
-// JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
-enum Error {
-  kErrorParseError = -32700,
-  kErrorInvalidRequest = -32600,
-  kErrorNoSuchMethod = -32601,
-  kErrorInvalidParams = -32602,
-  kErrorInternalError = -32603,
-  kErrorServerError = -32000
-};
-
-}  // namespace
-
-using base::Value;
-
-DevToolsProtocol::Message::~Message() {
-}
-
-DevToolsProtocol::Message::Message(const std::string& method,
-                                   base::DictionaryValue* params)
-    : method_(method),
-      params_(params) {
-  size_t pos = method.find(".");
-  if (pos != std::string::npos && pos > 0)
-    domain_ = method.substr(0, pos);
-}
-
-DevToolsProtocol::Command::~Command() {
-}
-
-std::string DevToolsProtocol::Command::Serialize() {
-  base::DictionaryValue command;
-  command.SetInteger(kIdParam, id_);
-  command.SetString(kMethodParam, method_);
-  if (params_)
-    command.Set(kParamsParam, params_->DeepCopy());
-
-  std::string json_command;
-  base::JSONWriter::Write(&command, &json_command);
-  return json_command;
-}
-
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::Command::SuccessResponse(base::DictionaryValue* result) {
-  return new DevToolsProtocol::Response(id_, result);
-}
-
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::Command::InternalErrorResponse(const std::string& message) {
-  return new DevToolsProtocol::Response(id_, kErrorInternalError, message);
-}
-
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::Command::InvalidParamResponse(const std::string& param) {
-  std::string message =
-      base::StringPrintf("Missing or invalid '%s' parameter", param.c_str());
-  return new DevToolsProtocol::Response(id_, kErrorInvalidParams, message);
-}
-
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::Command::NoSuchMethodErrorResponse() {
-  return new Response(id_, kErrorNoSuchMethod, "No such method");
-}
-
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::Command::ServerErrorResponse(const std::string& message) {
-  return new Response(id_, kErrorServerError, message);
-}
-
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::Command::AsyncResponsePromise() {
-  scoped_refptr<DevToolsProtocol::Response> promise =
-      new DevToolsProtocol::Response(0, NULL);
-  promise->is_async_promise_ = true;
-  return promise;
-}
-
-DevToolsProtocol::Command::Command(int id,
-                                   const std::string& method,
-                                   base::DictionaryValue* params)
-    : Message(method, params),
-      id_(id) {
-}
-
-DevToolsProtocol::Response::~Response() {
-}
-
-std::string DevToolsProtocol::Response::Serialize() {
-  base::DictionaryValue response;
-
-  if (id_ != kNoId)
-    response.SetInteger(kIdParam, id_);
-
-  if (error_code_) {
-    base::DictionaryValue* error_object = new base::DictionaryValue();
-    response.Set(kErrorParam, error_object);
-    error_object->SetInteger(kErrorCodeParam, error_code_);
-    if (!error_message_.empty())
-      error_object->SetString(kErrorMessageParam, error_message_);
-  } else {
-    if (result_)
-      response.Set(kResultParam, result_->DeepCopy());
-    else
-      response.Set(kResultParam, new base::DictionaryValue());
-  }
-
-  std::string json_response;
-  base::JSONWriter::Write(&response, &json_response);
-  return json_response;
-}
-
-DevToolsProtocol::Response::Response(int id, base::DictionaryValue* result)
-    : id_(id),
-      result_(result),
-      error_code_(0),
-      is_async_promise_(false) {
-}
-
-DevToolsProtocol::Response::Response(int id,
-                                     int error_code,
-                                     const std::string& error_message)
-    : id_(id),
-      error_code_(error_code),
-      error_message_(error_message),
-      is_async_promise_(false) {
-}
-
-DevToolsProtocol::Notification::Notification(const std::string& method,
-                                             base::DictionaryValue* params)
-    : Message(method, params) {
-}
-
-DevToolsProtocol::Notification::~Notification() {
-}
-
-std::string DevToolsProtocol::Notification::Serialize() {
-  base::DictionaryValue notification;
-  notification.SetString(kMethodParam, method_);
-  if (params_)
-    notification.Set(kParamsParam, params_->DeepCopy());
-
-  std::string json_notification;
-  base::JSONWriter::Write(&notification, &json_notification);
-  return json_notification;
-}
-
-DevToolsProtocol::Handler::~Handler() {
-}
-
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::Handler::HandleCommand(
-    scoped_refptr<DevToolsProtocol::Command> command) {
-  CommandHandlers::iterator it = command_handlers_.find(command->method());
-  if (it == command_handlers_.end())
-    return NULL;
-  return (it->second).Run(command);
-}
-
-void DevToolsProtocol::Handler::SetNotifier(const Notifier& notifier) {
-  notifier_ = notifier;
-}
-
-DevToolsProtocol::Handler::Handler() {
-}
-
-void DevToolsProtocol::Handler::RegisterCommandHandler(
-    const std::string& command,
-    const CommandHandler& handler) {
-  command_handlers_[command] = handler;
-}
-
-void DevToolsProtocol::Handler::SendNotification(
-    const std::string& method,
-    base::DictionaryValue* params) {
-  scoped_refptr<DevToolsProtocol::Notification> notification =
-      new DevToolsProtocol::Notification(method, params);
-  SendRawMessage(notification->Serialize());
-}
-
-void DevToolsProtocol::Handler::SendAsyncResponse(
-    scoped_refptr<DevToolsProtocol::Response> response) {
-  SendRawMessage(response->Serialize());
-}
-
-void DevToolsProtocol::Handler::SendRawMessage(const std::string& message) {
-  if (!notifier_.is_null())
-    notifier_.Run(message);
-}
-
-static bool ParseMethod(base::DictionaryValue* command,
-                        std::string* method) {
-  if (!command->GetString(kMethodParam, method))
-    return false;
-  size_t pos = method->find(".");
-  if (pos == std::string::npos || pos == 0)
-    return false;
-  return true;
-}
-
-// static
-scoped_refptr<DevToolsProtocol::Command> DevToolsProtocol::ParseCommand(
-    const std::string& json,
-    std::string* error_response) {
-  scoped_ptr<base::DictionaryValue> command_dict(
-      ParseMessage(json, error_response));
-  return ParseCommand(command_dict.get(), error_response);
-}
-
-// static
-scoped_refptr<DevToolsProtocol::Command> DevToolsProtocol::ParseCommand(
-    base::DictionaryValue* command_dict,
-    std::string* error_response) {
-  if (!command_dict)
-    return NULL;
-
-  int id;
-  std::string method;
-  bool ok = command_dict->GetInteger(kIdParam, &id) && id >= 0;
-  ok = ok && ParseMethod(command_dict, &method);
-  if (!ok) {
-    scoped_refptr<Response> response =
-        new Response(kNoId, kErrorInvalidRequest, "No such method");
-    *error_response = response->Serialize();
-    return NULL;
-  }
-
-  base::DictionaryValue* params = NULL;
-  command_dict->GetDictionary(kParamsParam, &params);
-  return new Command(id, method, params ? params->DeepCopy() : NULL);
-}
-
-// static
-scoped_refptr<DevToolsProtocol::Command>
-DevToolsProtocol::CreateCommand(
-    int id,
-    const std::string& method,
-    base::DictionaryValue* params) {
-  return new Command(id, method, params);
-}
-
-//static
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocol::ParseResponse(
-    base::DictionaryValue* response_dict) {
-  int id;
-  if (!response_dict->GetInteger(kIdParam, &id))
-    id = kNoId;
-
-  const base::DictionaryValue* error_dict;
-  if (response_dict->GetDictionary(kErrorParam, &error_dict)) {
-    int error_code = kErrorInternalError;
-    response_dict->GetInteger(kErrorCodeParam, &error_code);
-    std::string error_message;
-    response_dict->GetString(kErrorMessageParam, &error_message);
-    return new Response(id, error_code, error_message);
-  }
-
-  const base::DictionaryValue* result = NULL;
-  response_dict->GetDictionary(kResultParam, &result);
-  return new Response(id, result ? result->DeepCopy() : NULL);
-}
-
-// static
-scoped_refptr<DevToolsProtocol::Notification>
-DevToolsProtocol::ParseNotification(const std::string& json) {
-  scoped_ptr<base::DictionaryValue> dict(ParseMessage(json, NULL));
-  if (!dict)
-    return NULL;
-
-  std::string method;
-  bool ok = ParseMethod(dict.get(), &method);
-  if (!ok)
-    return NULL;
-
-  base::DictionaryValue* params = NULL;
-  dict->GetDictionary(kParamsParam, &params);
-  return new Notification(method, params ? params->DeepCopy() : NULL);
-}
-
-//static
-scoped_refptr<DevToolsProtocol::Notification>
-DevToolsProtocol::CreateNotification(
-    const std::string& method,
-    base::DictionaryValue* params) {
-  return new Notification(method, params);
-}
-
-// static
-base::DictionaryValue* DevToolsProtocol::ParseMessage(
-    const std::string& json,
-    std::string* error_response) {
-  int parse_error_code;
-  std::string error_message;
-  scoped_ptr<base::Value> message(
-      base::JSONReader::ReadAndReturnError(
-          json, 0, &parse_error_code, &error_message));
-
-  if (!message || !message->IsType(base::Value::TYPE_DICTIONARY)) {
-    scoped_refptr<Response> response =
-        new Response(0, kErrorParseError, error_message);
-    if (error_response)
-      *error_response = response->Serialize();
-    return NULL;
-  }
-
-  return static_cast<base::DictionaryValue*>(message.release());
-}
-
-}  // namespace content
diff --git a/content/browser/devtools/devtools_protocol.h b/content/browser/devtools/devtools_protocol.h
deleted file mode 100644
index 50dc8a6..0000000
--- a/content/browser/devtools/devtools_protocol.h
+++ /dev/null
@@ -1,195 +0,0 @@
-// Copyright (c) 2013 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_DEVTOOLS_PROTOCOL_H_
-#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_PROTOCOL_H_
-
-#include <map>
-#include <string>
-
-#include "base/basictypes.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/memory/ref_counted.h"
-#include "base/values.h"
-#include "content/common/content_export.h"
-
-namespace content {
-
-// Utility classes for processing DevTools remote debugging messages.
-// https://developers.google.com/chrome-developer-tools/docs/debugger-protocol
-class DevToolsProtocol {
- public:
-  typedef base::Callback<void(const std::string& message)> Notifier;
-
-  class Response;
-
-  class Message : public base::RefCountedThreadSafe<Message> {
-   public:
-    std::string domain() { return domain_; }
-    std::string method() { return method_; }
-    base::DictionaryValue* params() { return params_.get(); }
-    virtual std::string Serialize() = 0;
-
-   protected:
-    friend class base::RefCountedThreadSafe<Message>;
-    virtual ~Message();
-    Message(const std::string& method,
-            base::DictionaryValue* params);
-
-    std::string domain_;
-    std::string method_;
-    scoped_ptr<base::DictionaryValue> params_;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Message);
-  };
-
-  class Command : public Message {
-   public:
-    int id() { return id_; }
-
-    std::string Serialize() override;
-
-    // Creates success response. Takes ownership of |result|.
-    scoped_refptr<Response> SuccessResponse(base::DictionaryValue* result);
-
-    // Creates error response.
-    scoped_refptr<Response> InternalErrorResponse(const std::string& message);
-
-    // Creates error response.
-    scoped_refptr<Response> InvalidParamResponse(const std::string& param);
-
-    // Creates error response.
-    scoped_refptr<Response> NoSuchMethodErrorResponse();
-
-    // Creates error response.
-    scoped_refptr<Response> ServerErrorResponse(const std::string& message);
-
-    // Creates async response promise.
-    scoped_refptr<Response> AsyncResponsePromise();
-
-   protected:
-    ~Command() override;
-
-   private:
-    friend class DevToolsProtocol;
-    Command(int id, const std::string& method,
-            base::DictionaryValue* params);
-
-    int id_;
-
-    DISALLOW_COPY_AND_ASSIGN(Command);
-  };
-
-  class Response : public base::RefCountedThreadSafe<Response> {
-   public:
-    std::string Serialize();
-
-    bool is_async_promise() { return is_async_promise_; }
-
-   private:
-    friend class base::RefCountedThreadSafe<Response>;
-    friend class Command;
-    friend class DevToolsProtocol;
-    virtual  ~Response();
-
-    Response(int id, base::DictionaryValue* result);
-    Response(int id, int error_code, const std::string& error_message);
-
-    int id_;
-    scoped_ptr<base::DictionaryValue> result_;
-    int error_code_;
-    std::string error_message_;
-    bool is_async_promise_;
-
-    DISALLOW_COPY_AND_ASSIGN(Response);
-  };
-
-  class Notification : public Message {
-   public:
-    std::string Serialize() override;
-
-   private:
-    friend class DevToolsProtocol;
-    friend class DevToolsProtocolClient;
-    ~Notification() override;
-
-    // Takes ownership of |params|.
-    Notification(const std::string& method,
-                 base::DictionaryValue* params);
-
-    DISALLOW_COPY_AND_ASSIGN(Notification);
-  };
-
-  class CONTENT_EXPORT Handler {
-   public:
-    typedef base::Callback<scoped_refptr<DevToolsProtocol::Response>(
-        scoped_refptr<DevToolsProtocol::Command> command)> CommandHandler;
-
-    virtual ~Handler();
-
-    virtual scoped_refptr<DevToolsProtocol::Response> HandleCommand(
-        scoped_refptr<DevToolsProtocol::Command> command);
-
-    void SetNotifier(const Notifier& notifier);
-
-   protected:
-    Handler();
-
-    void RegisterCommandHandler(const std::string& command,
-                                const CommandHandler& handler);
-
-    // Sends notification to the client. Takes ownership of |params|.
-    void SendNotification(const std::string& method,
-                          base::DictionaryValue* params);
-
-    void SendAsyncResponse(scoped_refptr<DevToolsProtocol::Response> response);
-
-    // Sends message to client, the caller is presumed to properly
-    // format the message.
-    void SendRawMessage(const std::string& message);
-
-   private:
-    typedef std::map<std::string, CommandHandler> CommandHandlers;
-
-    Notifier notifier_;
-    CommandHandlers command_handlers_;
-
-    DISALLOW_COPY_AND_ASSIGN(Handler);
-  };
-
-  CONTENT_EXPORT static base::DictionaryValue* ParseMessage(
-      const std::string& json,
-      std::string* error_response);
-
-  CONTENT_EXPORT static scoped_refptr<Command> ParseCommand(
-      const std::string& json,
-      std::string* error_response);
-
-  CONTENT_EXPORT static scoped_refptr<Command> ParseCommand(
-      base::DictionaryValue* command_dict,
-      std::string* error_response);
-
-  CONTENT_EXPORT static scoped_refptr<Command> CreateCommand(
-      int id,
-      const std::string& method,
-      base::DictionaryValue* params);
-
-  CONTENT_EXPORT static scoped_refptr<Response> ParseResponse(
-      base::DictionaryValue* response_dict);
-
-  static scoped_refptr<Notification> ParseNotification(
-      const std::string& json);
-
-  static scoped_refptr<Notification> CreateNotification(
-      const std::string& method, base::DictionaryValue* params);
-
-  DevToolsProtocol() {}
-  ~DevToolsProtocol() {}
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_PROTOCOL_H_
diff --git a/content/browser/devtools/embedded_worker_devtools_agent_host.cc b/content/browser/devtools/embedded_worker_devtools_agent_host.cc
index 54766f8..8da53a8 100644
--- a/content/browser/devtools/embedded_worker_devtools_agent_host.cc
+++ b/content/browser/devtools/embedded_worker_devtools_agent_host.cc
@@ -5,7 +5,7 @@
 #include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
 
 #include "base/strings/utf_string_conversions.h"
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/shared_worker/shared_worker_service_impl.h"
diff --git a/content/browser/devtools/embedded_worker_devtools_manager.cc b/content/browser/devtools/embedded_worker_devtools_manager.cc
index 37263659..1e36e76 100644
--- a/content/browser/devtools/embedded_worker_devtools_manager.cc
+++ b/content/browser/devtools/embedded_worker_devtools_manager.cc
@@ -5,7 +5,6 @@
 #include "content/browser/devtools/embedded_worker_devtools_manager.h"
 
 #include "content/browser/devtools/devtools_manager.h"
-#include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
 #include "content/browser/devtools/ipc_devtools_agent_host.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
diff --git a/content/browser/devtools/renderer_overrides_handler_browsertest.cc b/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
index fd02c09..31ccdbe 100644
--- a/content/browser/devtools/renderer_overrides_handler_browsertest.cc
+++ b/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
@@ -5,7 +5,7 @@
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
-#include "content/browser/devtools/devtools_protocol.h"
+#include "base/json/json_writer.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
@@ -17,13 +17,28 @@
 
 namespace content {
 
-class RendererOverridesHandlerTest : public ContentBrowserTest,
-                                     public DevToolsAgentHostClient {
+namespace {
+
+const char kIdParam[] = "id";
+const char kMethodParam[] = "method";
+const char kParamsParam[] = "params";
+
+}
+
+class DevToolsProtocolTest : public ContentBrowserTest,
+                             public DevToolsAgentHostClient {
  protected:
   void SendCommand(const std::string& method,
-                   base::DictionaryValue* params) {
-    agent_host_->DispatchProtocolMessage(
-        DevToolsProtocol::CreateCommand(1, method, params)->Serialize());
+                   scoped_ptr<base::DictionaryValue> params) {
+    base::DictionaryValue command;
+    command.SetInteger(kIdParam, 1);
+    command.SetString(kMethodParam, method);
+    if (params)
+      command.Set(kParamsParam, params.release());
+
+    std::string json_command;
+    base::JSONWriter::Write(&command, &json_command);
+    agent_host_->DispatchProtocolMessage(json_command);
     base::MessageLoop::current()->Run();
   }
 
@@ -81,10 +96,10 @@ class RendererOverridesHandlerTest : public ContentBrowserTest,
   }
 };
 
-IN_PROC_BROWSER_TEST_F(RendererOverridesHandlerTest, QueryUsageAndQuota) {
-  base::DictionaryValue* params = new base::DictionaryValue();
+IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, QueryUsageAndQuota) {
+  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue);
   params->SetString("securityOrigin", "http://example.com");
-  SendCommand("Page.queryUsageAndQuota", params);
+  SendCommand("Page.queryUsageAndQuota", params.Pass());
 
   EXPECT_TRUE(HasValue("quota.persistent"));
   EXPECT_TRUE(HasValue("quota.temporary"));
@@ -95,7 +110,7 @@ IN_PROC_BROWSER_TEST_F(RendererOverridesHandlerTest, QueryUsageAndQuota) {
   EXPECT_TRUE(HasListItem("usage.persistent", "id", "filesystem"));
 }
 
-class CaptureScreenshotTest : public RendererOverridesHandlerTest {
+class CaptureScreenshotTest : public DevToolsProtocolTest {
  private:
 #if !defined(OS_ANDROID)
   void SetUpCommandLine(base::CommandLine* command_line) override {
@@ -120,7 +135,7 @@ IN_PROC_BROWSER_TEST_F(CaptureScreenshotTest, MAYBE_CaptureScreenshot) {
   EXPECT_TRUE(content::ExecuteScript(
       shell()->web_contents()->GetRenderViewHost(),
       "document.body.style.background = '#123456'"));
-  SendCommand("Page.captureScreenshot", new base::DictionaryValue());
+  SendCommand("Page.captureScreenshot", nullptr);
   std::string base64;
   EXPECT_TRUE(result_->GetString("data", &base64));
   std::string png;
diff --git a/content/browser/devtools/protocol/devtools_protocol_client.cc b/content/browser/devtools/protocol/devtools_protocol_client.cc
index e959da9..28af8e5 100644
--- a/content/browser/devtools/protocol/devtools_protocol_client.cc
+++ b/content/browser/devtools/protocol/devtools_protocol_client.cc
@@ -4,8 +4,34 @@
 
 #include "content/browser/devtools/protocol/devtools_protocol_client.h"
 
+#include "base/json/json_writer.h"
+#include "base/strings/stringprintf.h"
+
 namespace content {
 
+namespace {
+
+const char kIdParam[] = "id";
+const char kMethodParam[] = "method";
+const char kParamsParam[] = "params";
+const char kResultParam[] = "result";
+const char kErrorParam[] = "error";
+const char kErrorCodeParam[] = "code";
+const char kErrorMessageParam[] = "message";
+
+// Special values.
+const int kStatusOk = -1;
+const int kStatusFallThrough = -2;
+// JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
+const int kStatusInvalidParams = -32602;
+const int kStatusInternalError = -32603;
+const int kStatusServerError = -32000;
+
+}  // namespace
+
+// static
+const DevToolsCommandId DevToolsProtocolClient::kNoId = -1;
+
 DevToolsProtocolClient::DevToolsProtocolClient(
     const RawMessageCallback& raw_message_callback)
     : raw_message_callback_(raw_message_callback) {
@@ -14,77 +40,83 @@ DevToolsProtocolClient::DevToolsProtocolClient(
 DevToolsProtocolClient::~DevToolsProtocolClient() {
 }
 
+void DevToolsProtocolClient::SendRawMessage(const std::string& message) {
+  raw_message_callback_.Run(message);
+}
+
+void DevToolsProtocolClient::SendMessage(const base::DictionaryValue& message) {
+  std::string json_message;
+  base::JSONWriter::Write(&message, &json_message);
+  SendRawMessage(json_message);
+}
+
 void DevToolsProtocolClient::SendNotification(
     const std::string& method,
     scoped_ptr<base::DictionaryValue> params) {
-  scoped_refptr<DevToolsProtocol::Notification> notification =
-      new DevToolsProtocol::Notification(method, params.release());
-  SendRawMessage(notification->Serialize());
-}
+  base::DictionaryValue notification;
+  notification.SetString(kMethodParam, method);
+  if (params)
+    notification.Set(kParamsParam, params.release());
 
-void DevToolsProtocolClient::SendAsyncResponse(
-    scoped_refptr<DevToolsProtocol::Response> response) {
-  SendRawMessage(response->Serialize());
+  SendMessage(notification);
 }
 
-void DevToolsProtocolClient::SendRawMessage(const std::string& message) {
-  raw_message_callback_.Run(message);
-}
+void DevToolsProtocolClient::SendSuccess(
+    DevToolsCommandId command_id,
+    scoped_ptr<base::DictionaryValue> params) {
+  base::DictionaryValue response;
+  response.SetInteger(kIdParam, command_id);
 
-void DevToolsProtocolClient::SendInvalidParamsResponse(
-    scoped_refptr<DevToolsProtocol::Command> command,
-    const std::string& message) {
-  SendAsyncResponse(command->InvalidParamResponse(message));
-}
+  response.Set(kResultParam,
+      params ? params.release() : new base::DictionaryValue());
 
-void DevToolsProtocolClient::SendInternalErrorResponse(
-    scoped_refptr<DevToolsProtocol::Command> command,
-    const std::string& message) {
-  SendAsyncResponse(command->InternalErrorResponse(message));
+  SendMessage(response);
 }
 
-void DevToolsProtocolClient::SendServerErrorResponse(
-    scoped_refptr<DevToolsProtocol::Command> command,
-    const std::string& message) {
-  SendAsyncResponse(command->ServerErrorResponse(message));
+bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id,
+                                       const Response& response) {
+  if (response.status() == kStatusOk ||
+      response.status() == kStatusFallThrough) {
+    return false;
+  }
+  base::DictionaryValue dict;
+  if (command_id != kNoId)
+    dict.SetInteger(kIdParam, command_id);
+
+  base::DictionaryValue* error_object = new base::DictionaryValue();
+  error_object->SetInteger(kErrorCodeParam, response.status());
+  if (!response.message().empty())
+    error_object->SetString(kErrorMessageParam, response.message());
+
+  dict.Set(kErrorParam, error_object);
+  SendMessage(dict);
+  return true;
 }
 
 typedef DevToolsProtocolClient::Response Response;
 
 Response Response::FallThrough() {
-  Response response;
-  response.status_ = ResponseStatus::RESPONSE_STATUS_FALLTHROUGH;
-  return response;
+  return Response(kStatusFallThrough);
 }
 
 Response Response::OK() {
-  Response response;
-  response.status_ = ResponseStatus::RESPONSE_STATUS_OK;
-  return response;
+  return Response(kStatusOk);
 }
 
-Response Response::InvalidParams(const std::string& message) {
-  Response response;
-  response.status_ = ResponseStatus::RESPONSE_STATUS_INVALID_PARAMS;
-  response.message_ = message;
-  return response;
+Response Response::InvalidParams(const std::string& param) {
+  return Response(kStatusInvalidParams,
+      base::StringPrintf("Missing or invalid '%s' parameter", param.c_str()));
 }
 
 Response Response::InternalError(const std::string& message) {
-  Response response;
-  response.status_ = ResponseStatus::RESPONSE_STATUS_INTERNAL_ERROR;
-  response.message_ = message;
-  return response;
+  return Response(kStatusInternalError, message);
 }
 
 Response Response::ServerError(const std::string& message) {
-  Response response;
-  response.status_ = ResponseStatus::RESPONSE_STATUS_SERVER_ERROR;
-  response.message_ = message;
-  return response;
+  return Response(kStatusServerError, message);
 }
 
-DevToolsProtocolClient::ResponseStatus Response::status() const {
+int Response::status() const {
   return status_;
 }
 
@@ -92,7 +124,17 @@ const std::string& Response::message() const {
   return message_;
 }
 
-Response::Response() {
+bool Response::IsFallThrough() const {
+  return status_ == kStatusFallThrough;
+}
+
+Response::Response(int status)
+    : status_(status) {
+}
+
+Response::Response(int status, const std::string& message)
+    : status_(status),
+      message_(message) {
 }
 
 }  // namespace content
diff --git a/content/browser/devtools/protocol/devtools_protocol_client.h b/content/browser/devtools/protocol/devtools_protocol_client.h
index 19f8fdf..9297187 100644
--- a/content/browser/devtools/protocol/devtools_protocol_client.h
+++ b/content/browser/devtools/protocol/devtools_protocol_client.h
@@ -5,68 +5,67 @@
 #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"
+#include "base/callback.h"
+#include "base/values.h"
 
 namespace content {
 
+using DevToolsCommandId = int;
+class DevToolsProtocolHandler;
+class DevToolsProtocolDispatcher;
+
 class DevToolsProtocolClient {
  public:
   typedef base::Callback<void(const std::string& message)>
       RawMessageCallback;
-
-  enum ResponseStatus {
-    RESPONSE_STATUS_FALLTHROUGH,
-    RESPONSE_STATUS_OK,
-    RESPONSE_STATUS_INVALID_PARAMS,
-    RESPONSE_STATUS_INTERNAL_ERROR,
-    RESPONSE_STATUS_SERVER_ERROR,
-  };
+  static const DevToolsCommandId kNoId;
 
   struct Response {
    public:
     static Response FallThrough();
     static Response OK();
-    static Response InvalidParams(const std::string& message);
+    static Response InvalidParams(const std::string& param);
     static Response InternalError(const std::string& message);
     static Response ServerError(const std::string& message);
 
-    ResponseStatus status() const;
+    int status() const;
     const std::string& message() const;
 
+    bool IsFallThrough() const;
+
    private:
-    Response();
+    friend class DevToolsProtocolHandler;
+
+    explicit Response(int status);
+    Response(int status, const std::string& message);
 
-    ResponseStatus status_;
+    int 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);
+  bool SendError(DevToolsCommandId command_id,
+                 const Response& response);
 
   // Sends message to client, the caller is presumed to properly
   // format the message. Do not use unless you must.
   void SendRawMessage(const std::string& message);
 
- protected:
-  DevToolsProtocolClient(const RawMessageCallback& raw_message_callback);
-
+  explicit DevToolsProtocolClient(
+      const RawMessageCallback& raw_message_callback);
   virtual ~DevToolsProtocolClient();
 
+ protected:
+  void SendSuccess(DevToolsCommandId command_id,
+                   scoped_ptr<base::DictionaryValue> params);
   void SendNotification(const std::string& method,
                         scoped_ptr<base::DictionaryValue> params);
 
-  void SendAsyncResponse(scoped_refptr<DevToolsProtocol::Response> response);
-
  private:
-  RawMessageCallback raw_message_callback_;
+  friend class DevToolsProtocolDispatcher;
+
+  void SendMessage(const base::DictionaryValue& message);
 
+  RawMessageCallback raw_message_callback_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsProtocolClient);
 };
 
diff --git a/content/browser/devtools/protocol/devtools_protocol_handler.cc b/content/browser/devtools/protocol/devtools_protocol_handler.cc
new file mode 100644
index 0000000..c9a38f2
--- /dev/null
+++ b/content/browser/devtools/protocol/devtools_protocol_handler.cc
@@ -0,0 +1,94 @@
+// 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_handler.h"
+
+#include "base/bind.h"
+#include "base/json/json_reader.h"
+
+namespace content {
+
+namespace {
+
+const char kIdParam[] = "id";
+const char kMethodParam[] = "method";
+const char kParamsParam[] = "params";
+
+// JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
+const int kStatusParseError = -32700;
+const int kStatusInvalidRequest = -32600;
+const int kStatusNoSuchMethod = -32601;
+
+scoped_ptr<base::DictionaryValue> TakeDictionary(base::DictionaryValue* dict,
+                                                 const std::string& key) {
+  scoped_ptr<base::Value> value;
+  dict->Remove(key, &value);
+  base::DictionaryValue* result = nullptr;
+  if (value)
+    value.release()->GetAsDictionary(&result);
+  return make_scoped_ptr(result);
+}
+
+}  // namespace
+
+DevToolsProtocolHandler::DevToolsProtocolHandler(bool handle_generic_errors,
+                                                 const Notifier& notifier)
+    : client_(notifier),
+      handle_generic_errors_(handle_generic_errors),
+      dispatcher_(notifier) {
+}
+
+DevToolsProtocolHandler::~DevToolsProtocolHandler() {
+}
+
+scoped_ptr<base::DictionaryValue>
+DevToolsProtocolHandler::ParseCommand(const std::string& message) {
+  std::string parse_error;
+  scoped_ptr<base::Value> value(
+      base::JSONReader::ReadAndReturnError(message, 0, nullptr, &parse_error));
+
+  if (!value) {
+    if (handle_generic_errors_) {
+      client_.SendError(DevToolsProtocolClient::kNoId,
+                        Response(kStatusParseError, parse_error));
+    }
+    return nullptr;
+  }
+  if (!value->IsType(base::Value::TYPE_DICTIONARY)) {
+    if (handle_generic_errors_) {
+      client_.SendError(DevToolsProtocolClient::kNoId,
+                        Response(kStatusInvalidRequest, "Not a dictionary"));
+    }
+    return nullptr;
+  }
+  return make_scoped_ptr(static_cast<base::DictionaryValue*>(value.release()));
+}
+
+bool DevToolsProtocolHandler::HandleCommand(
+    scoped_ptr<base::DictionaryValue> command) {
+  int id = DevToolsProtocolClient::kNoId;
+  std::string method;
+  bool ok = command->GetInteger(kIdParam, &id) && id >= 0;
+  ok = ok && command->GetString(kMethodParam, &method);
+  if (!ok) {
+    if (handle_generic_errors_) {
+      client_.SendError(id, Response(kStatusInvalidRequest, "Invalid request"));
+      return true;
+    }
+    return false;
+  }
+  DevToolsProtocolDispatcher::CommandHandler command_handler(
+      dispatcher_.FindCommandHandler(method));
+  if (command_handler.is_null()) {
+    if (handle_generic_errors_) {
+      client_.SendError(id, Response(kStatusNoSuchMethod, "No such method"));
+      return true;
+    }
+    return false;
+
+  }
+  return command_handler.Run(id, TakeDictionary(command.get(), kParamsParam));
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/protocol/devtools_protocol_handler.h b/content/browser/devtools/protocol/devtools_protocol_handler.h
new file mode 100644
index 0000000..e0be9d4
--- /dev/null
+++ b/content/browser/devtools/protocol/devtools_protocol_handler.h
@@ -0,0 +1,34 @@
+// 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_HANDLER_H_
+#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_H_
+
+#include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h"
+
+namespace content {
+
+class DevToolsProtocolHandler {
+ public:
+  using Response = DevToolsProtocolClient::Response;
+  using Notifier = base::Callback<void(const std::string& message)>;
+
+  DevToolsProtocolHandler(bool handle_generic_errors,
+                          const Notifier& notifier);
+  virtual ~DevToolsProtocolHandler();
+
+  scoped_ptr<base::DictionaryValue> ParseCommand(const std::string& message);
+  bool HandleCommand(scoped_ptr<base::DictionaryValue> command);
+
+  DevToolsProtocolDispatcher* dispatcher() { return &dispatcher_; }
+
+ private:
+  DevToolsProtocolClient client_;
+  bool handle_generic_errors_;
+  DevToolsProtocolDispatcher dispatcher_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_H_
diff --git a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
index e35f2f9..d3dd9c1 100755
--- a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
+++ b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
@@ -26,15 +26,14 @@ header = """\
 
 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_
+#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
+#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
 
-#include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/protocol/devtools_protocol_client.h"
 
 namespace content {
 
-class DevToolsProtocolHandlerImpl;
+class DevToolsProtocolDispatcher;
 
 namespace devtools {
 
@@ -73,25 +72,34 @@ ${types}\
 
 }  // namespace devtools
 
-class DevToolsProtocolHandlerImpl : public DevToolsProtocol::Handler {
+class DevToolsProtocolDispatcher {
  public:
-  typedef DevToolsProtocolClient::Response Response;
-  typedef DevToolsProtocolClient::ResponseStatus ResponseStatus;
+  using Notifier = DevToolsProtocolClient::RawMessageCallback;
+  using CommandHandler =
+      base::Callback<bool(int, scoped_ptr<base::DictionaryValue>)>;
 
-  DevToolsProtocolHandlerImpl();
-  virtual ~DevToolsProtocolHandlerImpl();
+  explicit DevToolsProtocolDispatcher(const Notifier& notifier);
+  ~DevToolsProtocolDispatcher();
+
+  CommandHandler FindCommandHandler(const std::string& method);
 
 ${setters}\
 
  private:
+  using Response = DevToolsProtocolClient::Response;
+  using CommandHandlers = std::map<std::string, CommandHandler>;
+
 ${methods}\
 
+  Notifier notifier_;
+  DevToolsProtocolClient client_;
+  CommandHandlers command_handlers_;
 ${fields}\
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_
+#endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
 """)
 
 tmpl_typedef = string.Template("""\
@@ -192,7 +200,7 @@ tmpl_client = string.Template("""\
 namespace ${domain} {
 class Client : public DevToolsProtocolClient {
  public:
-  Client(const RawMessageCallback& raw_message_callback);
+  explicit Client(const RawMessageCallback& raw_message_callback);
   virtual ~Client();
 
 ${methods}\
@@ -207,7 +215,7 @@ tmpl_event = string.Template("""\
 
 tmpl_response = string.Template("""\
   void Send${Command}Response(
-      scoped_refptr<DevToolsProtocol::Command> command,
+      DevToolsCommandId command_id,
       scoped_refptr<${Command}Response> params);
 """)
 
@@ -217,9 +225,9 @@ tmpl_setter = string.Template("""\
 """)
 
 tmpl_callback = string.Template("""\
-  scoped_refptr<DevToolsProtocol::Response>
-  On${Domain}${Command}(
-      scoped_refptr<DevToolsProtocol::Command> command);
+  bool On${Domain}${Command}(
+      DevToolsCommandId command_id,
+      scoped_ptr<base::DictionaryValue> params);
 """)
 
 tmpl_field = string.Template("""\
@@ -228,7 +236,7 @@ tmpl_field = string.Template("""\
 
 template_cc = string.Template(header + """\
 
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
@@ -236,42 +244,22 @@ ${includes}\
 
 namespace content {
 
-DevToolsProtocolHandlerImpl::DevToolsProtocolHandlerImpl()
-    : ${fields_init} {
+DevToolsProtocolDispatcher::DevToolsProtocolDispatcher(
+    const Notifier& notifier)
+    : notifier_(notifier),
+      client_(notifier),
+      ${fields_init} {
 }
 
-DevToolsProtocolHandlerImpl::~DevToolsProtocolHandlerImpl() {
+DevToolsProtocolDispatcher::~DevToolsProtocolDispatcher() {
 }
 
-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 = nullptr;
-      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;
+DevToolsProtocolDispatcher::CommandHandler
+DevToolsProtocolDispatcher::FindCommandHandler(const std::string& method) {
+  CommandHandlers::iterator it = command_handlers_.find(method);
+  return it == command_handlers_.end() ? CommandHandler() : it->second;
 }
 
-}  // namespace
-
 ${methods}\
 
 namespace devtools {
@@ -306,7 +294,7 @@ tmpl_include = string.Template("""\
 tmpl_field_init = string.Template("${domain}_handler_(nullptr)")
 
 tmpl_setter_impl = string.Template("""\
-void DevToolsProtocolHandlerImpl::Set${Domain}Handler(
+void DevToolsProtocolDispatcher::Set${Domain}Handler(
     devtools::${domain}::${Domain}Handler* ${domain}_handler) {
   DCHECK(!${domain}_handler_);
   ${domain}_handler_ = ${domain}_handler;
@@ -315,32 +303,32 @@ ${initializations}\
 """)
 
 tmpl_register = string.Template("""\
-  RegisterCommandHandler(
-      "${Domain}.${command}",
+  command_handlers_["${Domain}.${command}"] =
       base::Bind(
-          &DevToolsProtocolHandlerImpl::On${Domain}${Command},
-          base::Unretained(this)));
+          &DevToolsProtocolDispatcher::On${Domain}${Command},
+          base::Unretained(this));
 """)
 
 tmpl_init_client = string.Template("""\
   ${domain}_handler_->SetClient(make_scoped_ptr(
-      new devtools::${domain}::Client(
-          base::Bind(&DevToolsProtocolHandlerImpl::SendRawMessage,
-                     base::Unretained(this)))));
+      new devtools::${domain}::Client(notifier_)));
 """)
 
 tmpl_callback_impl = string.Template("""\
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocolHandlerImpl::On${Domain}${Command}(
-    scoped_refptr<DevToolsProtocol::Command> command) {
+bool DevToolsProtocolDispatcher::On${Domain}${Command}(
+    DevToolsCommandId command_id,
+    scoped_ptr<base::DictionaryValue> params) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
-  scoped_refptr<DevToolsProtocol::Response> protocol_response;
-  if (CreateCommonResponse(command, response, &protocol_response))
-    return protocol_response;
-  base::DictionaryValue* result = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> protocol_response;
+  if (client_.SendError(command_id, response))
+    return true;
+  if (response.IsFallThrough())
+    return false;
+  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 ${wrap}\
-  return command->SuccessResponse(result);
+  client_.SendSuccess(command_id, result.Pass());
+  return true;
 }
 """)
 
@@ -349,34 +337,39 @@ tmpl_wrap = string.Template("""\
 """)
 
 tmpl_callback_async_impl = string.Template("""\
-scoped_refptr<DevToolsProtocol::Response>
-DevToolsProtocolHandlerImpl::On${Domain}${Command}(
-    scoped_refptr<DevToolsProtocol::Command> command) {
+bool DevToolsProtocolDispatcher::On${Domain}${Command}(
+    DevToolsCommandId command_id,
+    scoped_ptr<base::DictionaryValue> params) {
 ${prep}\
-  return ${domain}_handler_->${Command}(${args});
+  Response response = ${domain}_handler_->${Command}(${args});
+  if (client_.SendError(command_id, response))
+    return true;
+  return !response.IsFallThrough();
 }
 """)
 
-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}");
+  if (!params || !params->Get${Type}("${proto_param}", &in_${param})) {
+    client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
+    return true;
+  }
 """)
 
 tmpl_prep_req_list = string.Template("""\
   base::ListValue* list_${param} = nullptr;
-  if (!params || !params->GetList("${proto_param}", &list_${param}))
-    return command->InvalidParamResponse("${proto_param}");
+  if (!params || !params->GetList("${proto_param}", &list_${param})) {
+    client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
+    return true;
+  }
   std::vector<${item_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}");
+    if (!(*it)->GetAs${ItemType}(&item)) {
+      client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
+      return true;
+    }
     in_${param}.push_back(item);
   }
 """)
@@ -422,9 +415,9 @@ void Client::${Command}(
 
 tmpl_response_impl = string.Template("""\
 void Client::Send${Command}Response(
-    scoped_refptr<DevToolsProtocol::Command> command,
+    DevToolsCommandId command_id,
     scoped_refptr<${Command}Response> params) {
-  SendAsyncResponse(command->SuccessResponse(params->ToValue().release()));
+  SendSuccess(command_id, params->ToValue().Pass());
 }
 """)
 
@@ -641,8 +634,6 @@ for json_domain in all_domains:
           param_map["proto_param"] = json_param["name"]
           param_map["param"] = Uncamelcase(json_param["name"])
           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
@@ -665,7 +656,7 @@ for json_domain in all_domains:
         # 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")
+        args.insert(0, "command_id")
         handler_method_impls.append(
             tmpl_callback_async_impl.substitute(command_map,
                 prep = "".join(prep),
diff --git a/content/browser/devtools/protocol/dom_handler.h b/content/browser/devtools/protocol/dom_handler.h
index d2b20e2..206bb7a 100644
--- a/content/browser/devtools/protocol/dom_handler.h
+++ b/content/browser/devtools/protocol/dom_handler.h
@@ -5,7 +5,7 @@
 #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"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 namespace content {
 
diff --git a/content/browser/devtools/protocol/input_handler.h b/content/browser/devtools/protocol/input_handler.h
index 1a85b2a..edb7183 100644
--- a/content/browser/devtools/protocol/input_handler.h
+++ b/content/browser/devtools/protocol/input_handler.h
@@ -5,7 +5,7 @@
 #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"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 namespace content {
 
diff --git a/content/browser/devtools/protocol/inspector_handler.h b/content/browser/devtools/protocol/inspector_handler.h
index 8c215e0..4045e29 100644
--- a/content/browser/devtools/protocol/inspector_handler.h
+++ b/content/browser/devtools/protocol/inspector_handler.h
@@ -5,7 +5,7 @@
 #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"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 namespace content {
 namespace devtools {
diff --git a/content/browser/devtools/protocol/network_handler.h b/content/browser/devtools/protocol/network_handler.h
index c045a86..9e811d3 100644
--- a/content/browser/devtools/protocol/network_handler.h
+++ b/content/browser/devtools/protocol/network_handler.h
@@ -5,7 +5,7 @@
 #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"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 namespace content {
 
diff --git a/content/browser/devtools/protocol/page_handler.cc b/content/browser/devtools/protocol/page_handler.cc
index fd456b4..ba8da7f 100644
--- a/content/browser/devtools/protocol/page_handler.cc
+++ b/content/browser/devtools/protocol/page_handler.cc
@@ -324,15 +324,14 @@ Response PageHandler::SetTouchEmulationEnabled(
   return Response::FallThrough();
 }
 
-scoped_refptr<DevToolsProtocol::Response> PageHandler::CaptureScreenshot(
-    scoped_refptr<DevToolsProtocol::Command> command) {
+Response PageHandler::CaptureScreenshot(DevToolsCommandId command_id) {
   if (!host_ || !host_->GetView())
-    return command->InternalErrorResponse("Could not connect to view");
+    return Response::InternalError("Could not connect to view");
 
   host_->GetSnapshotFromBrowser(
       base::Bind(&PageHandler::ScreenshotCaptured,
-          weak_factory_.GetWeakPtr(), command));
-  return command->AsyncResponsePromise();
+          weak_factory_.GetWeakPtr(), command_id));
+  return Response::OK();
 }
 
 Response PageHandler::CanScreencast(bool* result) {
@@ -422,11 +421,10 @@ Response PageHandler::HandleJavaScriptDialog(bool accept,
   return Response::InternalError("Could not handle JavaScript dialog");
 }
 
-scoped_refptr<DevToolsProtocol::Response> PageHandler::QueryUsageAndQuota(
-    const std::string& security_origin,
-    scoped_refptr<DevToolsProtocol::Command> command) {
+Response PageHandler::QueryUsageAndQuota(DevToolsCommandId command_id,
+                                         const std::string& security_origin) {
   if (!host_)
-    return command->InternalErrorResponse("Could not connect to view");
+    return Response::InternalError("Could not connect to view");
 
   scoped_refptr<storage::QuotaManager> quota_manager =
       host_->GetProcess()->GetStoragePartition()->GetQuotaManager();
@@ -439,9 +437,8 @@ scoped_refptr<DevToolsProtocol::Response> PageHandler::QueryUsageAndQuota(
                  GURL(security_origin),
                  base::Bind(&PageHandler::QueryUsageAndQuotaCompleted,
                             weak_factory_.GetWeakPtr(),
-                            command)));
-
-  return command->AsyncResponsePromise();
+                            command_id)));
+  return Response::OK();
 }
 
 Response PageHandler::SetColorPickerEnabled(bool enabled) {
@@ -580,13 +577,12 @@ void PageHandler::ScreencastFrameEncoded(
       ->set_frame_number(++screencast_frame_sent_));
 }
 
-void PageHandler::ScreenshotCaptured(
-    scoped_refptr<DevToolsProtocol::Command> command,
-    const unsigned char* png_data,
-    size_t png_size) {
+void PageHandler::ScreenshotCaptured(DevToolsCommandId command_id,
+                                     const unsigned char* png_data,
+                                     size_t png_size) {
   if (!png_data || !png_size) {
-    client_->SendInternalErrorResponse(command,
-                                       "Unable to capture screenshot");
+    client_->SendError(command_id,
+                       Response::InternalError("Unable to capture screenshot"));
     return;
   }
 
@@ -595,7 +591,7 @@ void PageHandler::ScreenshotCaptured(
       base::StringPiece(reinterpret_cast<const char*>(png_data), png_size),
       &base_64_data);
 
-  client_->SendCaptureScreenshotResponse(command,
+  client_->SendCaptureScreenshotResponse(command_id,
       CaptureScreenshotResponse::Create()->set_data(base_64_data));
 }
 
@@ -606,9 +602,9 @@ void PageHandler::OnColorPicked(int r, int g, int b, int a) {
 }
 
 void PageHandler::QueryUsageAndQuotaCompleted(
-    scoped_refptr<DevToolsProtocol::Command> command,
+    DevToolsCommandId command_id,
     scoped_refptr<QueryUsageAndQuotaResponse> response_data) {
-  client_->SendQueryUsageAndQuotaResponse(command, response_data);
+  client_->SendQueryUsageAndQuotaResponse(command_id, response_data);
 }
 
 }  // namespace page
diff --git a/content/browser/devtools/protocol/page_handler.h b/content/browser/devtools/protocol/page_handler.h
index 90dad5d..68e19ef 100644
--- a/content/browser/devtools/protocol/page_handler.h
+++ b/content/browser/devtools/protocol/page_handler.h
@@ -10,7 +10,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "cc/output/compositor_frame_metadata.h"
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/public/browser/readback_types.h"
 
 class SkBitmap;
@@ -64,8 +64,7 @@ class PageHandler {
   Response SetTouchEmulationEnabled(bool enabled,
                                     const std::string* configuration);
 
-  scoped_refptr<DevToolsProtocol::Response> CaptureScreenshot(
-      scoped_refptr<DevToolsProtocol::Command> command);
+  Response CaptureScreenshot(DevToolsCommandId command_id);
 
   Response CanScreencast(bool* result);
   Response CanEmulate(bool* result);
@@ -79,9 +78,8 @@ class PageHandler {
 
   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 QueryUsageAndQuota(DevToolsCommandId command_id,
+                              const std::string& security_origin);
 
   Response SetColorPickerEnabled(bool enabled);
 
@@ -98,14 +96,14 @@ class PageHandler {
                               const std::string& data);
 
   void ScreenshotCaptured(
-      scoped_refptr<DevToolsProtocol::Command> command,
+      DevToolsCommandId command_id,
       const unsigned char* png_data,
       size_t png_size);
 
   void OnColorPicked(int r, int g, int b, int a);
 
   void QueryUsageAndQuotaCompleted(
-      scoped_refptr<DevToolsProtocol::Command> command,
+      DevToolsCommandId command_id,
       scoped_refptr<QueryUsageAndQuotaResponse> response);
 
   bool enabled_;
diff --git a/content/browser/devtools/protocol/power_handler.h b/content/browser/devtools/protocol/power_handler.h
index f0892c7..cd7e8da 100644
--- a/content/browser/devtools/protocol/power_handler.h
+++ b/content/browser/devtools/protocol/power_handler.h
@@ -5,7 +5,7 @@
 #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"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/browser/power_profiler/power_profiler_observer.h"
 
 namespace content {
diff --git a/content/browser/devtools/protocol/system_info_handler.h b/content/browser/devtools/protocol/system_info_handler.h
index ed5936e0..2e8366f 100644
--- a/content/browser/devtools/protocol/system_info_handler.h
+++ b/content/browser/devtools/protocol/system_info_handler.h
@@ -5,7 +5,7 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_SYSTEM_INFO_HANDLER_H_
 #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_SYSTEM_INFO_HANDLER_H_
 
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 namespace content {
 namespace devtools {
diff --git a/content/browser/devtools/protocol/tethering_handler.cc b/content/browser/devtools/protocol/tethering_handler.cc
index 5029f873..0f00194 100644
--- a/content/browser/devtools/protocol/tethering_handler.cc
+++ b/content/browser/devtools/protocol/tethering_handler.cc
@@ -26,6 +26,8 @@ const int kBufferSize = 16 * 1024;
 const int kMinTetheringPort = 1024;
 const int kMaxTetheringPort = 32767;
 
+using Response = DevToolsProtocolClient::Response;
+
 class SocketPump {
  public:
   SocketPump(DevToolsHttpHandlerDelegate* delegate,
@@ -237,12 +239,12 @@ class TetheringHandler::TetheringImpl {
       DevToolsHttpHandlerDelegate* delegate);
   ~TetheringImpl();
 
-  void Bind(scoped_refptr<DevToolsProtocol::Command> command, uint16 port);
-  void Unbind(scoped_refptr<DevToolsProtocol::Command> command, uint16 port);
+  void Bind(DevToolsCommandId command_id, uint16 port);
+  void Unbind(DevToolsCommandId command_id, uint16 port);
   void Accepted(uint16 port, const std::string& name);
 
  private:
-  void SendInternalError(scoped_refptr<DevToolsProtocol::Command> command,
+  void SendInternalError(DevToolsCommandId command_id,
                          const std::string& message);
 
   base::WeakPtr<TetheringHandler> handler_;
@@ -265,9 +267,9 @@ TetheringHandler::TetheringImpl::~TetheringImpl() {
 }
 
 void TetheringHandler::TetheringImpl::Bind(
-    scoped_refptr<DevToolsProtocol::Command> command, uint16 port) {
+    DevToolsCommandId command_id, uint16 port) {
   if (bound_sockets_.find(port) != bound_sockets_.end()) {
-    SendInternalError(command, "Port already bound");
+    SendInternalError(command_id, "Port already bound");
     return;
   }
 
@@ -275,7 +277,7 @@ void TetheringHandler::TetheringImpl::Bind(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
   scoped_ptr<BoundSocket> bound_socket(new BoundSocket(callback, delegate_));
   if (!bound_socket->Listen(port)) {
-    SendInternalError(command, "Could not bind port");
+    SendInternalError(command_id, "Could not bind port");
     return;
   }
 
@@ -283,15 +285,15 @@ void TetheringHandler::TetheringImpl::Bind(
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&TetheringHandler::SendBindSuccess, handler_, command));
+      base::Bind(&TetheringHandler::SendBindSuccess, handler_, command_id));
 }
 
 void TetheringHandler::TetheringImpl::Unbind(
-    scoped_refptr<DevToolsProtocol::Command> command, uint16 port) {
+    DevToolsCommandId command_id, uint16 port) {
 
   BoundSockets::iterator it = bound_sockets_.find(port);
   if (it == bound_sockets_.end()) {
-    SendInternalError(command, "Port is not bound");
+    SendInternalError(command_id, "Port is not bound");
     return;
   }
 
@@ -300,7 +302,7 @@ void TetheringHandler::TetheringImpl::Unbind(
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&TetheringHandler::SendUnbindSuccess, handler_, command));
+      base::Bind(&TetheringHandler::SendUnbindSuccess, handler_, command_id));
 }
 
 void TetheringHandler::TetheringImpl::Accepted(
@@ -312,13 +314,13 @@ void TetheringHandler::TetheringImpl::Accepted(
 }
 
 void TetheringHandler::TetheringImpl::SendInternalError(
-    scoped_refptr<DevToolsProtocol::Command> command,
+    DevToolsCommandId command_id,
     const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&TetheringHandler::SendInternalError, handler_,
-                 command, message));
+                 command_id, message));
 }
 
 
@@ -362,51 +364,44 @@ bool TetheringHandler::Activate() {
   return true;
 }
 
-scoped_refptr<DevToolsProtocol::Response> TetheringHandler::Bind(
-    uint16 port, scoped_refptr<DevToolsProtocol::Command> command) {
+Response TetheringHandler::Bind(DevToolsCommandId command_id, int port) {
   if (port < kMinTetheringPort || port > kMaxTetheringPort)
-    return command->InvalidParamResponse("port");
+    return Response::InvalidParams("port");
+
+  if (!Activate())
+    return Response::ServerError("Tethering is used by another connection");
 
-  if (!Activate()) {
-    return command->ServerErrorResponse(
-        "Tethering is used by another connection");
-  }
   DCHECK(impl_);
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&TetheringImpl::Bind, base::Unretained(impl_),
-                 command, port));
-  return command->AsyncResponsePromise();
+                 command_id, port));
+  return Response::OK();
 }
 
-scoped_refptr<DevToolsProtocol::Response> TetheringHandler::Unbind(
-    uint16 port, scoped_refptr<DevToolsProtocol::Command> command) {
-  if (!Activate()) {
-    return command->ServerErrorResponse(
-        "Tethering is used by another connection");
-  }
+Response TetheringHandler::Unbind(DevToolsCommandId command_id, int port) {
+  if (!Activate())
+    return Response::ServerError("Tethering is used by another connection");
+
   DCHECK(impl_);
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&TetheringImpl::Unbind, base::Unretained(impl_),
-                 command, port));
-  return command->AsyncResponsePromise();
+                 command_id, port));
+  return Response::OK();
 }
 
-void TetheringHandler::SendBindSuccess(
-    scoped_refptr<DevToolsProtocol::Command> command) {
-  client_->SendBindResponse(command, BindResponse::Create());
+void TetheringHandler::SendBindSuccess(DevToolsCommandId command_id) {
+  client_->SendBindResponse(command_id, BindResponse::Create());
 }
 
-void TetheringHandler::SendUnbindSuccess(
-    scoped_refptr<DevToolsProtocol::Command> command) {
-  client_->SendUnbindResponse(command, UnbindResponse::Create());
+void TetheringHandler::SendUnbindSuccess(DevToolsCommandId command_id) {
+  client_->SendUnbindResponse(command_id, UnbindResponse::Create());
 }
 
-void TetheringHandler::SendInternalError(
-    scoped_refptr<DevToolsProtocol::Command> command,
-    const std::string& message) {
-  client_->SendInternalErrorResponse(command, message);
+void TetheringHandler::SendInternalError(DevToolsCommandId command_id,
+                                         const std::string& message) {
+  client_->SendError(command_id, Response::InternalError(message));
 }
 
 }  // namespace tethering
diff --git a/content/browser/devtools/protocol/tethering_handler.h b/content/browser/devtools/protocol/tethering_handler.h
index 89467c9..a98da1e 100644
--- a/content/browser/devtools/protocol/tethering_handler.h
+++ b/content/browser/devtools/protocol/tethering_handler.h
@@ -7,7 +7,7 @@
 
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 namespace content {
 
@@ -19,16 +19,16 @@ namespace tethering {
 // This class implements reversed tethering handler.
 class TetheringHandler {
  public:
+  using Response = DevToolsProtocolClient::Response;
+
   TetheringHandler(DevToolsHttpHandlerDelegate* delegate,
                    scoped_refptr<base::MessageLoopProxy> message_loop_proxy);
   ~TetheringHandler();
 
   void SetClient(scoped_ptr<Client> client);
 
-  scoped_refptr<DevToolsProtocol::Response> Bind(
-      uint16 port, scoped_refptr<DevToolsProtocol::Command> command);
-  scoped_refptr<DevToolsProtocol::Response> Unbind(
-      uint16 port, scoped_refptr<DevToolsProtocol::Command> command);
+  Response Bind(DevToolsCommandId command_id, int port);
+  Response Unbind(DevToolsCommandId command_id, int port);
 
  private:
   class TetheringImpl;
@@ -36,9 +36,9 @@ class TetheringHandler {
   void Accepted(uint16 port, const std::string& name);
   bool Activate();
 
-  void SendBindSuccess(scoped_refptr<DevToolsProtocol::Command> command);
-  void SendUnbindSuccess(scoped_refptr<DevToolsProtocol::Command> command);
-  void SendInternalError(scoped_refptr<DevToolsProtocol::Command> command,
+  void SendBindSuccess(DevToolsCommandId command_id);
+  void SendUnbindSuccess(DevToolsCommandId command_id);
+  void SendInternalError(DevToolsCommandId command_id,
                          const std::string& message);
 
   scoped_ptr<Client> client_;
diff --git a/content/browser/devtools/protocol/tracing_handler.cc b/content/browser/devtools/protocol/tracing_handler.cc
index 29d1641..74446ca 100644
--- a/content/browser/devtools/protocol/tracing_handler.cc
+++ b/content/browser/devtools/protocol/tracing_handler.cc
@@ -83,15 +83,14 @@ void TracingHandler::OnTraceComplete() {
   client_->TracingComplete(TracingCompleteParams::Create());
 }
 
-scoped_refptr<DevToolsProtocol::Response> TracingHandler::Start(
-    const std::string* categories,
-    const std::string* options_str,
-    const double* buffer_usage_reporting_interval,
-    scoped_refptr<DevToolsProtocol::Command> command) {
+Response TracingHandler::Start(DevToolsCommandId command_id,
+                               const std::string* categories,
+                               const std::string* options_str,
+                               const double* buffer_usage_reporting_interval) {
   if (is_recording_)
-    return command->InternalErrorResponse("Tracing is already started");
-  is_recording_ = true;
+    return Response::InternalError("Tracing is already started");
 
+  is_recording_ = true;
   base::debug::TraceOptions options = TraceOptionsFromString(options_str);
   base::debug::CategoryFilter filter(categories ? *categories : std::string());
   if (buffer_usage_reporting_interval)
@@ -104,7 +103,7 @@ scoped_refptr<DevToolsProtocol::Response> TracingHandler::Start(
         filter,
         options,
         TracingController::EnableRecordingDoneCallback());
-    return nullptr;
+    return Response::FallThrough();
   }
 
   TracingController::GetInstance()->EnableRecording(
@@ -112,34 +111,30 @@ scoped_refptr<DevToolsProtocol::Response> TracingHandler::Start(
       options,
       base::Bind(&TracingHandler::OnRecordingEnabled,
                  weak_factory_.GetWeakPtr(),
-                 command));
-  return command->AsyncResponsePromise();
+                 command_id));
+  return Response::OK();
 }
 
-scoped_refptr<DevToolsProtocol::Response> TracingHandler::End(
-    scoped_refptr<DevToolsProtocol::Command> command) {
+Response TracingHandler::End(DevToolsCommandId command_id) {
   if (!is_recording_)
-    return command->InternalErrorResponse("Tracing is not started");
+    return Response::InternalError("Tracing is not started");
+
   DisableRecording(false);
   // If inspected target is a render process Tracing.end will be handled by
   // tracing agent in the renderer.
-  if (target_ == Renderer)
-    return nullptr;
-  return command->SuccessResponse(nullptr);
+  return target_ == Renderer ? Response::FallThrough() : Response::OK();
 }
 
-scoped_refptr<DevToolsProtocol::Response> TracingHandler::GetCategories(
-    scoped_refptr<DevToolsProtocol::Command> command) {
+Response TracingHandler::GetCategories(DevToolsCommandId command_id) {
   TracingController::GetInstance()->GetCategories(
       base::Bind(&TracingHandler::OnCategoriesReceived,
                  weak_factory_.GetWeakPtr(),
-                 command));
-  return command->AsyncResponsePromise();
+                 command_id));
+  return Response::OK();
 }
 
-void TracingHandler::OnRecordingEnabled(
-    scoped_refptr<DevToolsProtocol::Command> command) {
-  client_->SendStartResponse(command, StartResponse::Create());
+void TracingHandler::OnRecordingEnabled(DevToolsCommandId command_id) {
+  client_->SendStartResponse(command_id, StartResponse::Create());
 }
 
 void TracingHandler::OnBufferUsage(float percent_full,
@@ -153,12 +148,12 @@ void TracingHandler::OnBufferUsage(float percent_full,
 }
 
 void TracingHandler::OnCategoriesReceived(
-    scoped_refptr<DevToolsProtocol::Command> command,
+    DevToolsCommandId command_id,
     const std::set<std::string>& category_set) {
   std::vector<std::string> categories;
   for (const std::string& category : category_set)
     categories.push_back(category);
-  client_->SendGetCategoriesResponse(command,
+  client_->SendGetCategoriesResponse(command_id,
       GetCategoriesResponse::Create()->set_categories(categories));
 }
 
diff --git a/content/browser/devtools/protocol/tracing_handler.h b/content/browser/devtools/protocol/tracing_handler.h
index 29da1d6..9a7efb3 100644
--- a/content/browser/devtools/protocol/tracing_handler.h
+++ b/content/browser/devtools/protocol/tracing_handler.h
@@ -10,7 +10,7 @@
 
 #include "base/debug/trace_event.h"
 #include "base/memory/weak_ptr.h"
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/public/browser/tracing_controller.h"
 
 namespace base {
@@ -36,22 +36,18 @@ class TracingHandler {
   void OnTraceDataCollected(const std::string& trace_fragment);
   void OnTraceComplete();
 
-  scoped_refptr<DevToolsProtocol::Response> Start(
-      const std::string* categories,
-      const std::string* options,
-      const double* buffer_usage_reporting_interval,
-      scoped_refptr<DevToolsProtocol::Command> command);
-
-  scoped_refptr<DevToolsProtocol::Response> End(
-      scoped_refptr<DevToolsProtocol::Command> command);
-  scoped_refptr<DevToolsProtocol::Response> GetCategories(
-      scoped_refptr<DevToolsProtocol::Command> command);
+  Response Start(DevToolsCommandId command_id,
+                 const std::string* categories,
+                 const std::string* options,
+                 const double* buffer_usage_reporting_interval);
+  Response End(DevToolsCommandId command_id);
+  Response GetCategories(DevToolsCommandId command);
 
  private:
-  void OnRecordingEnabled(scoped_refptr<DevToolsProtocol::Command> command);
+  void OnRecordingEnabled(DevToolsCommandId command_id);
   void OnBufferUsage(float percent_full, size_t approximate_event_count);
 
-  void OnCategoriesReceived(scoped_refptr<DevToolsProtocol::Command> command,
+  void OnCategoriesReceived(DevToolsCommandId command_id,
                             const std::set<std::string>& category_set);
 
   base::debug::TraceOptions TraceOptionsFromString(const std::string* options);
diff --git a/content/browser/devtools/protocol/usage_and_quota_query.h b/content/browser/devtools/protocol/usage_and_quota_query.h
index 3a62e35..c3d7d87 100644
--- a/content/browser/devtools/protocol/usage_and_quota_query.h
+++ b/content/browser/devtools/protocol/usage_and_quota_query.h
@@ -5,7 +5,7 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_QUOTA_AND_USAGE_QUERY_H_
 #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_QUOTA_AND_USAGE_QUERY_H_
 
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "storage/browser/quota/quota_manager.h"
 
 namespace content {
diff --git a/content/browser/devtools/protocol/worker_handler.cc b/content/browser/devtools/protocol/worker_handler.cc
index fd8fc09..9baee17 100644
--- a/content/browser/devtools/protocol/worker_handler.cc
+++ b/content/browser/devtools/protocol/worker_handler.cc
@@ -9,7 +9,6 @@ namespace devtools {
 namespace worker {
 
 typedef DevToolsProtocolClient::Response Response;
-typedef DevToolsProtocolClient::ResponseStatus ResponseStatus;
 
 WorkerHandler::WorkerHandler() {
 }
diff --git a/content/browser/devtools/protocol/worker_handler.h b/content/browser/devtools/protocol/worker_handler.h
index 1c1faaf..b4ff38f 100644
--- a/content/browser/devtools/protocol/worker_handler.h
+++ b/content/browser/devtools/protocol/worker_handler.h
@@ -5,7 +5,7 @@
 #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"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 
 namespace content {
 namespace devtools {
diff --git a/content/browser/devtools/render_view_devtools_agent_host.cc b/content/browser/devtools/render_view_devtools_agent_host.cc
index a333957..ebb0aef 100644
--- a/content/browser/devtools/render_view_devtools_agent_host.cc
+++ b/content/browser/devtools/render_view_devtools_agent_host.cc
@@ -5,12 +5,12 @@
 #include "content/browser/devtools/render_view_devtools_agent_host.h"
 
 #include "base/basictypes.h"
+#include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/devtools_manager.h"
-#include "content/browser/devtools/devtools_protocol.h"
-#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/browser/devtools/protocol/dom_handler.h"
 #include "content/browser/devtools/protocol/input_handler.h"
 #include "content/browser/devtools/protocol/inspector_handler.h"
@@ -122,20 +122,20 @@ RenderViewDevToolsAgentHost::RenderViewDevToolsAgentHost(RenderViewHost* rvh)
       power_handler_(new devtools::power::PowerHandler()),
       tracing_handler_(new devtools::tracing::TracingHandler(
           devtools::tracing::TracingHandler::Renderer)),
-      handler_impl_(new DevToolsProtocolHandlerImpl()),
+      protocol_handler_(new DevToolsProtocolHandler(
+          false /* handle_generic_errors */,
+          base::Bind(&RenderViewDevToolsAgentHost::DispatchOnInspectorFrontend,
+                     base::Unretained(this)))),
       reattaching_(false) {
-  handler_impl_->SetDOMHandler(dom_handler_.get());
-  handler_impl_->SetInputHandler(input_handler_.get());
-  handler_impl_->SetInspectorHandler(inspector_handler_.get());
-  handler_impl_->SetNetworkHandler(network_handler_.get());
-  handler_impl_->SetPageHandler(page_handler_.get());
-  handler_impl_->SetPowerHandler(power_handler_.get());
-  handler_impl_->SetTracingHandler(tracing_handler_.get());
+  DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
+  dispatcher->SetDOMHandler(dom_handler_.get());
+  dispatcher->SetInputHandler(input_handler_.get());
+  dispatcher->SetInspectorHandler(inspector_handler_.get());
+  dispatcher->SetNetworkHandler(network_handler_.get());
+  dispatcher->SetPageHandler(page_handler_.get());
+  dispatcher->SetPowerHandler(power_handler_.get());
+  dispatcher->SetTracingHandler(tracing_handler_.get());
   SetRenderViewHost(rvh);
-  DevToolsProtocol::Notifier notifier(base::Bind(
-      &RenderViewDevToolsAgentHost::DispatchOnInspectorFrontend,
-      base::Unretained(this)));
-  handler_impl_->SetNotifier(notifier);
   g_instances.Get().push_back(this);
   AddRef();  // Balanced in RenderViewHostDestroyed.
   DevToolsManager::GetInstance()->AgentHostChanged(this);
@@ -152,32 +152,24 @@ WebContents* RenderViewDevToolsAgentHost::GetWebContents() {
 
 void RenderViewDevToolsAgentHost::DispatchProtocolMessage(
     const std::string& message) {
-  std::string error_message;
-
-  scoped_ptr<base::DictionaryValue> message_dict(
-      DevToolsProtocol::ParseMessage(message, &error_message));
-  scoped_refptr<DevToolsProtocol::Command> command =
-      DevToolsProtocol::ParseCommand(message_dict.get(), &error_message);
-
-  if (command.get()) {
-    scoped_refptr<DevToolsProtocol::Response> overridden_response;
 
+  scoped_ptr<base::DictionaryValue> command =
+      protocol_handler_->ParseCommand(message);
+  if (command) {
     DevToolsManagerDelegate* delegate =
         DevToolsManager::GetInstance()->delegate();
     if (delegate) {
-      scoped_ptr<base::DictionaryValue> overridden_response_value(
-          delegate->HandleCommand(this, message_dict.get()));
-      if (overridden_response_value)
-        overridden_response = DevToolsProtocol::ParseResponse(
-            overridden_response_value.get());
+      scoped_ptr<base::DictionaryValue> response(
+          delegate->HandleCommand(this, command.get()));
+      if (response) {
+        std::string json_response;
+        base::JSONWriter::Write(response.get(), &json_response);
+        DispatchOnInspectorFrontend(json_response);
+        return;
+      }
     }
-    if (!overridden_response.get())
-      overridden_response = handler_impl_->HandleCommand(command);
-    if (overridden_response.get()) {
-      if (!overridden_response->is_async_promise())
-        DispatchOnInspectorFrontend(overridden_response->Serialize());
+    if (protocol_handler_->HandleCommand(command.Pass()))
       return;
-    }
   }
 
   IPCDevToolsAgentHost::DispatchProtocolMessage(message);
diff --git a/content/browser/devtools/render_view_devtools_agent_host.h b/content/browser/devtools/render_view_devtools_agent_host.h
index 19690ee..b860103 100644
--- a/content/browser/devtools/render_view_devtools_agent_host.h
+++ b/content/browser/devtools/render_view_devtools_agent_host.h
@@ -23,7 +23,7 @@ class CompositorFrameMetadata;
 namespace content {
 
 class BrowserContext;
-class DevToolsProtocolHandlerImpl;
+class DevToolsProtocolHandler;
 class RenderViewHost;
 class RenderViewHostImpl;
 
@@ -124,7 +124,7 @@ class CONTENT_EXPORT RenderViewDevToolsAgentHost
   scoped_ptr<devtools::page::PageHandler> page_handler_;
   scoped_ptr<devtools::power::PowerHandler> power_handler_;
   scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
-  scoped_ptr<DevToolsProtocolHandlerImpl> handler_impl_;
+  scoped_ptr<DevToolsProtocolHandler> protocol_handler_;
 #if defined(OS_ANDROID)
   scoped_ptr<PowerSaveBlockerImpl> power_save_blocker_;
 #endif
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index 45809ab..a270562 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -451,8 +451,6 @@
       'browser/devtools/devtools_manager.h',
       'browser/devtools/devtools_netlog_observer.cc',
       'browser/devtools/devtools_netlog_observer.h',
-      'browser/devtools/devtools_protocol.cc',
-      'browser/devtools/devtools_protocol.h',
       'browser/devtools/forwarding_agent_host.cc',
       'browser/devtools/forwarding_agent_host.h',
       'browser/devtools/ipc_devtools_agent_host.cc',
@@ -465,6 +463,8 @@
       'browser/devtools/protocol/color_picker.h',
       'browser/devtools/protocol/devtools_protocol_client.cc',
       'browser/devtools/protocol/devtools_protocol_client.h',
+      'browser/devtools/protocol/devtools_protocol_handler.cc',
+      'browser/devtools/protocol/devtools_protocol_handler.h',
       'browser/devtools/protocol/dom_handler.cc',
       'browser/devtools/protocol/dom_handler.h',
       'browser/devtools/protocol/input_handler.cc',
@@ -1424,8 +1424,8 @@
       '<(SHARED_INTERMEDIATE_DIR)/content/browser/tracing/grit/tracing_resources.h',
       '<(SHARED_INTERMEDIATE_DIR)/ui/resources/grit/webui_resources_map.cc',
       # 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',
+      '<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_dispatcher.cc',
+      '<(SHARED_INTERMEDIATE_DIR)/content/browser/devtools/protocol/devtools_protocol_dispatcher.h',
     ],
     'android_browser_sources': [
       'browser/android/java/gin_java_bound_object.cc',
diff --git a/content/content_tests.gypi b/content/content_tests.gypi
index 50d3238..2ef67e1 100644
--- a/content/content_tests.gypi
+++ b/content/content_tests.gypi
@@ -1225,7 +1225,7 @@
             'browser/cross_site_transfer_browsertest.cc',
             'browser/database_browsertest.cc',
             'browser/device_sensors/device_inertial_sensor_browsertest.cc',
-            'browser/devtools/renderer_overrides_handler_browsertest.cc',
+            'browser/devtools/protocol/devtools_protocol_browsertest.cc',
             'browser/dom_storage/dom_storage_browsertest.cc',
             'browser/download/download_browsertest.cc',
             'browser/download/drag_download_file_browsertest.cc',