[DevTools] filter any messages from previous session in DevToolsAgentHostImpl

Frontend can receive response for protocol message that was sent by previous session or notification that was produced during previous session. E.g. frontend send protocol message and then reattach and then get response.
session_id for protocol message is added in this CL. DevToolsAgentHostImpl store current session_id, RenderFrameDevToolsAgentHost and WorkerDevToolsAgentHost add to each protocol message session id and SendResponseMessageToClient method check it after processing.
WebDevToolsAgentImpl get session_id from Attach or Reattach IPC message, clear session_id on Dettach message and use it for notifications.

BUG=503875, 503824
TEST=run blink/tools/run_layout_tests.py inspector/sources/debugger-breakpoints/set-conditional-breakpoint.html --repeat-each 2
R=pfeldman@chromium.org, dgozman@chromium.org
TBR=jam@chromium.org, tsepez@chromium.org

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

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

29 files changed, 291 insertions, 196 deletions

diff --git a/content/browser/devtools/browser_devtools_agent_host.cc b/content/browser/devtools/browser_devtools_agent_host.cc
index d045571..d7c3423 100644
--- a/content/browser/devtools/browser_devtools_agent_host.cc
+++ b/content/browser/devtools/browser_devtools_agent_host.cc
@@ -31,10 +31,7 @@ BrowserDevToolsAgentHost::BrowserDevToolsAgentHost(
                                                     tethering_task_runner)),
       tracing_handler_(new devtools::tracing::TracingHandler(
           devtools::tracing::TracingHandler::Browser, GetIOContext())),
-      protocol_handler_(new DevToolsProtocolHandler(
-          this,
-          base::Bind(&BrowserDevToolsAgentHost::SendMessageToClient,
-                     base::Unretained(this)))) {
+      protocol_handler_(new DevToolsProtocolHandler(this)) {
   DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
   dispatcher->SetIOHandler(io_handler_.get());
   dispatcher->SetMemoryHandler(memory_handler_.get());
@@ -74,7 +71,7 @@ bool BrowserDevToolsAgentHost::Close() {
 
 bool BrowserDevToolsAgentHost::DispatchProtocolMessage(
     const std::string& message) {
-  protocol_handler_->HandleMessage(message);
+  protocol_handler_->HandleMessage(session_id(), message);
   return true;
 }
 
diff --git a/content/browser/devtools/devtools_agent_host_impl.cc b/content/browser/devtools/devtools_agent_host_impl.cc
index 4d93551..7385def 100644
--- a/content/browser/devtools/devtools_agent_host_impl.cc
+++ b/content/browser/devtools/devtools_agent_host_impl.cc
@@ -76,8 +76,7 @@ scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForWorker(
 }
 
 DevToolsAgentHostImpl::DevToolsAgentHostImpl()
-    : id_(base::GenerateGUID()),
-      client_(NULL) {
+    : id_(base::GenerateGUID()), session_id_(0), client_(NULL) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_instances.Get()[id_] = this;
 }
@@ -106,6 +105,7 @@ scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::Create(
 
 void DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
+  ++session_id_;
   if (client_) {
     client_->AgentHostClosed(this, true);
     InnerDetach();
@@ -153,6 +153,16 @@ void DevToolsAgentHostImpl::DisconnectWebContents() {
 void DevToolsAgentHostImpl::ConnectWebContents(WebContents* wc) {
 }
 
+void DevToolsAgentHostImpl::SendProtocolResponse(int session_id,
+                                                 const std::string& message) {
+  SendMessageToClient(session_id, message);
+}
+
+void DevToolsAgentHostImpl::SendProtocolNotification(
+    const std::string& message) {
+  SendMessageToClient(session_id_, message);
+}
+
 void DevToolsAgentHostImpl::HostClosed() {
   if (!client_)
     return;
@@ -164,9 +174,13 @@ void DevToolsAgentHostImpl::HostClosed() {
   client->AgentHostClosed(this, false);
 }
 
-void DevToolsAgentHostImpl::SendMessageToClient(const std::string& message) {
+void DevToolsAgentHostImpl::SendMessageToClient(int session_id,
+                                                const std::string& message) {
   if (!client_)
     return;
+  // Filter any messages from previous sessions.
+  if (session_id != session_id_)
+    return;
   client_->DispatchProtocolMessage(this, message);
 }
 
@@ -249,7 +263,7 @@ void DevToolsMessageChunkProcessor::ProcessChunkedMessageFromAgent(
 
   if (chunk.is_first && chunk.is_last) {
     CHECK(message_buffer_size_ == 0);
-    callback_.Run(chunk.data);
+    callback_.Run(chunk.session_id, chunk.data);
     return;
   }
 
@@ -265,7 +279,7 @@ void DevToolsMessageChunkProcessor::ProcessChunkedMessageFromAgent(
 
   if (chunk.is_last) {
     CHECK(message_buffer_.size() == message_buffer_size_);
-    callback_.Run(message_buffer_);
+    callback_.Run(chunk.session_id, message_buffer_);
     message_buffer_ = std::string();
     message_buffer_size_ = 0;
   }
diff --git a/content/browser/devtools/devtools_agent_host_impl.h b/content/browser/devtools/devtools_agent_host_impl.h
index 8474c0a..2dc09cc 100644
--- a/content/browser/devtools/devtools_agent_host_impl.h
+++ b/content/browser/devtools/devtools_agent_host_impl.h
@@ -9,6 +9,7 @@
 
 #include "base/compiler_specific.h"
 #include "content/browser/devtools/devtools_io_context.h"
+#include "content/browser/devtools/protocol/devtools_protocol_delegate.h"
 #include "content/common/content_export.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/devtools_agent_host.h"
@@ -22,7 +23,8 @@ namespace content {
 class BrowserContext;
 
 // Describes interface for managing devtools agents from the browser process.
-class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
+class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost,
+                                             public DevToolsProtocolDelegate {
  public:
   // Informs the hosted agent that a client host has attached.
   virtual void Attach() = 0;
@@ -44,14 +46,21 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
   void DisconnectWebContents() override;
   void ConnectWebContents(WebContents* wc) override;
 
+  // DevToolsProtocolDelegate implementation.
+  void SendProtocolResponse(int session_id,
+                            const std::string& message) override;
+  void SendProtocolNotification(const std::string& message) override;
+
  protected:
   DevToolsAgentHostImpl();
   ~DevToolsAgentHostImpl() override;
 
   void HostClosed();
-  void SendMessageToClient(const std::string& message);
+  void SendMessageToClient(int session_id, const std::string& message);
   devtools::DevToolsIOContext* GetIOContext() { return &io_context_; }
 
+  int session_id() { DCHECK(client_); return session_id_; }
+
   static void NotifyCallbacks(DevToolsAgentHostImpl* agent_host, bool attached);
 
  private:
@@ -59,13 +68,14 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
   void InnerDetach();
 
   const std::string id_;
+  int session_id_;
   DevToolsAgentHostClient* client_;
   devtools::DevToolsIOContext io_context_;
 };
 
 class DevToolsMessageChunkProcessor {
  public:
-  using SendMessageCallback = base::Callback<void(const std::string&)>;
+  using SendMessageCallback = base::Callback<void(int, const std::string&)>;
   explicit DevToolsMessageChunkProcessor(const SendMessageCallback& callback);
   ~DevToolsMessageChunkProcessor();
 
diff --git a/content/browser/devtools/devtools_protocol_handler.cc b/content/browser/devtools/devtools_protocol_handler.cc
index 86ccd8e..9f69cfb 100644
--- a/content/browser/devtools/devtools_protocol_handler.cc
+++ b/content/browser/devtools/devtools_protocol_handler.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/browser/devtools/devtools_manager.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 
@@ -36,35 +37,35 @@ scoped_ptr<base::DictionaryValue> TakeDictionary(base::DictionaryValue* dict,
 }  // namespace
 
 DevToolsProtocolHandler::DevToolsProtocolHandler(
-    DevToolsAgentHost* agent_host, const Notifier& notifier)
-    : agent_host_(agent_host),
-      client_(notifier),
-      dispatcher_(notifier) {
-}
+    DevToolsAgentHostImpl* agent_host)
+    : agent_host_(agent_host), client_(agent_host), dispatcher_(agent_host) {}
 
 DevToolsProtocolHandler::~DevToolsProtocolHandler() {
 }
 
-void DevToolsProtocolHandler::HandleMessage(const std::string& message) {
-  scoped_ptr<base::DictionaryValue> command = ParseCommand(message);
+void DevToolsProtocolHandler::HandleMessage(int session_id,
+                                            const std::string& message) {
+  scoped_ptr<base::DictionaryValue> command = ParseCommand(session_id, message);
   if (!command)
     return;
-  if (PassCommandToDelegate(command.get()))
+  if (PassCommandToDelegate(session_id, command.get()))
     return;
-  HandleCommand(command.Pass());
+  HandleCommand(session_id, command.Pass());
 }
 
-bool DevToolsProtocolHandler::HandleOptionalMessage(
-    const std::string& message, int* call_id) {
-  scoped_ptr<base::DictionaryValue> command = ParseCommand(message);
+bool DevToolsProtocolHandler::HandleOptionalMessage(int session_id,
+                                                    const std::string& message,
+                                                    int* call_id) {
+  scoped_ptr<base::DictionaryValue> command = ParseCommand(session_id, message);
   if (!command)
     return true;
-  if (PassCommandToDelegate(command.get()))
+  if (PassCommandToDelegate(session_id, command.get()))
     return true;
-  return HandleOptionalCommand(command.Pass(), call_id);
+  return HandleOptionalCommand(session_id, command.Pass(), call_id);
 }
 
 bool DevToolsProtocolHandler::PassCommandToDelegate(
+    int session_id,
     base::DictionaryValue* command) {
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
@@ -74,41 +75,41 @@ bool DevToolsProtocolHandler::PassCommandToDelegate(
   scoped_ptr<base::DictionaryValue> response(
       delegate->HandleCommand(agent_host_, command));
   if (response) {
-    std::string json_response;
-    base::JSONWriter::Write(*response, &json_response);
-    client_.SendRawMessage(json_response);
+    client_.SendMessage(session_id, *response);
     return true;
   }
 
   return false;
 }
 
-scoped_ptr<base::DictionaryValue>
-DevToolsProtocolHandler::ParseCommand(const std::string& message) {
+scoped_ptr<base::DictionaryValue> DevToolsProtocolHandler::ParseCommand(
+    int session_id,
+    const std::string& message) {
   scoped_ptr<base::Value> value = base::JSONReader::Read(message);
   if (!value || !value->IsType(base::Value::TYPE_DICTIONARY)) {
-    client_.SendError(DevToolsProtocolClient::kNoId,
-                      Response(kStatusParseError,
-                               "Message must be in JSON format"));
+    client_.SendError(
+        DevToolsCommandId(DevToolsCommandId::kNoId, session_id),
+        Response(kStatusParseError, "Message must be in JSON format"));
     return nullptr;
   }
 
   scoped_ptr<base::DictionaryValue> command =
       make_scoped_ptr(static_cast<base::DictionaryValue*>(value.release()));
-  int id = DevToolsProtocolClient::kNoId;
-  bool ok = command->GetInteger(kIdParam, &id) && id >= 0;
+  int call_id = DevToolsCommandId::kNoId;
+  bool ok = command->GetInteger(kIdParam, &call_id) && call_id >= 0;
   if (!ok) {
-    client_.SendError(id, Response(kStatusInvalidRequest,
-                                   "The type of 'id' property must be number"));
+    client_.SendError(DevToolsCommandId(call_id, session_id),
+                      Response(kStatusInvalidRequest,
+                               "The type of 'id' property must be number"));
     return nullptr;
   }
 
   std::string method;
   ok = command->GetString(kMethodParam, &method);
   if (!ok) {
-    client_.SendError(id,
-        Response(kStatusInvalidRequest,
-                 "The type of 'method' property must be string"));
+    client_.SendError(DevToolsCommandId(call_id, session_id),
+                      Response(kStatusInvalidRequest,
+                               "The type of 'method' property must be string"));
     return nullptr;
   }
 
@@ -116,34 +117,39 @@ DevToolsProtocolHandler::ParseCommand(const std::string& message) {
 }
 
 void DevToolsProtocolHandler::HandleCommand(
+    int session_id,
     scoped_ptr<base::DictionaryValue> command) {
-  int id = DevToolsProtocolClient::kNoId;
+  int call_id = DevToolsCommandId::kNoId;
   std::string method;
-  command->GetInteger(kIdParam, &id);
+  command->GetInteger(kIdParam, &call_id);
   command->GetString(kMethodParam, &method);
   DevToolsProtocolDispatcher::CommandHandler command_handler(
       dispatcher_.FindCommandHandler(method));
   if (command_handler.is_null()) {
-    client_.SendError(id, Response(kStatusNoSuchMethod, "No such method"));
+    client_.SendError(DevToolsCommandId(call_id, session_id),
+                      Response(kStatusNoSuchMethod, "No such method"));
     return;
   }
 
   bool result =
-      command_handler.Run(id, TakeDictionary(command.get(), kParamsParam));
+      command_handler.Run(DevToolsCommandId(call_id, session_id),
+                          TakeDictionary(command.get(), kParamsParam));
   DCHECK(result);
 }
 
 bool DevToolsProtocolHandler::HandleOptionalCommand(
-    scoped_ptr<base::DictionaryValue> command, int* call_id) {
-  *call_id = DevToolsProtocolClient::kNoId;
+    int session_id,
+    scoped_ptr<base::DictionaryValue> command,
+    int* call_id) {
+  *call_id = DevToolsCommandId::kNoId;
   std::string method;
   command->GetInteger(kIdParam, call_id);
   command->GetString(kMethodParam, &method);
   DevToolsProtocolDispatcher::CommandHandler command_handler(
       dispatcher_.FindCommandHandler(method));
   if (!command_handler.is_null()) {
-    return command_handler.Run(
-        *call_id, TakeDictionary(command.get(), kParamsParam));
+    return command_handler.Run(DevToolsCommandId(*call_id, session_id),
+                               TakeDictionary(command.get(), kParamsParam));
   }
   return false;
 }
diff --git a/content/browser/devtools/devtools_protocol_handler.h b/content/browser/devtools/devtools_protocol_handler.h
index 299b342..32f4928 100644
--- a/content/browser/devtools/devtools_protocol_handler.h
+++ b/content/browser/devtools/devtools_protocol_handler.h
@@ -10,26 +10,30 @@
 namespace content {
 
 class DevToolsAgentHost;
+class DevToolsAgentHostImpl;
+class DevToolsProtocolDelegate;
 
 class DevToolsProtocolHandler {
  public:
   using Response = DevToolsProtocolClient::Response;
-  using Notifier = base::Callback<void(const std::string& message)>;
 
-  DevToolsProtocolHandler(DevToolsAgentHost* agent_host,
-                          const Notifier& notifier);
+  explicit DevToolsProtocolHandler(DevToolsAgentHostImpl* agent_host);
   virtual ~DevToolsProtocolHandler();
 
-  void HandleMessage(const std::string& message);
-  bool HandleOptionalMessage(const std::string& message, int* call_id);
+  void HandleMessage(int session_id, const std::string& message);
+  bool HandleOptionalMessage(int session_id,
+                             const std::string& message,
+                             int* call_id);
 
   DevToolsProtocolDispatcher* dispatcher() { return &dispatcher_; }
 
  private:
-  scoped_ptr<base::DictionaryValue> ParseCommand(const std::string& message);
-  bool PassCommandToDelegate(base::DictionaryValue* command);
-  void HandleCommand(scoped_ptr<base::DictionaryValue> command);
-  bool HandleOptionalCommand(scoped_ptr<base::DictionaryValue> command,
+  scoped_ptr<base::DictionaryValue> ParseCommand(int session_id,
+                                                 const std::string& message);
+  bool PassCommandToDelegate(int session_id, base::DictionaryValue* command);
+  void HandleCommand(int session_id, scoped_ptr<base::DictionaryValue> command);
+  bool HandleOptionalCommand(int session_id,
+                             scoped_ptr<base::DictionaryValue> command,
                              int* call_id);
 
   DevToolsAgentHost* agent_host_;
diff --git a/content/browser/devtools/forwarding_agent_host.cc b/content/browser/devtools/forwarding_agent_host.cc
index ef7f82c..b8b8c2f 100644
--- a/content/browser/devtools/forwarding_agent_host.cc
+++ b/content/browser/devtools/forwarding_agent_host.cc
@@ -18,7 +18,7 @@ ForwardingAgentHost::~ForwardingAgentHost() {
 }
 
 void ForwardingAgentHost::DispatchOnClientHost(const std::string& message) {
-  SendMessageToClient(message);
+  SendMessageToClient(session_id(), message);
 }
 
 void ForwardingAgentHost::ConnectionClosed() {
diff --git a/content/browser/devtools/protocol/devtools_protocol_client.cc b/content/browser/devtools/protocol/devtools_protocol_client.cc
index 4b7c25d..9ca03f9 100644
--- a/content/browser/devtools/protocol/devtools_protocol_client.cc
+++ b/content/browser/devtools/protocol/devtools_protocol_client.cc
@@ -6,6 +6,7 @@
 
 #include "base/json/json_writer.h"
 #include "base/strings/stringprintf.h"
+#include "content/browser/devtools/protocol/devtools_protocol_delegate.h"
 
 namespace content {
 
@@ -30,24 +31,24 @@ const int kStatusServerError = -32000;
 }  // namespace
 
 // static
-const DevToolsCommandId DevToolsProtocolClient::kNoId = -1;
+const int DevToolsCommandId::kNoId = -1;
 
 DevToolsProtocolClient::DevToolsProtocolClient(
-    const RawMessageCallback& raw_message_callback)
-    : raw_message_callback_(raw_message_callback) {
-}
+    DevToolsProtocolDelegate* notifier)
+    : notifier_(notifier) {}
 
 DevToolsProtocolClient::~DevToolsProtocolClient() {
 }
 
-void DevToolsProtocolClient::SendRawMessage(const std::string& message) {
-  raw_message_callback_.Run(message);
+void DevToolsProtocolClient::SendRawNotification(const std::string& message) {
+  notifier_->SendProtocolNotification(message);
 }
 
-void DevToolsProtocolClient::SendMessage(const base::DictionaryValue& message) {
+void DevToolsProtocolClient::SendMessage(int session_id,
+                                         const base::DictionaryValue& message) {
   std::string json_message;
   base::JSONWriter::Write(message, &json_message);
-  SendRawMessage(json_message);
+  notifier_->SendProtocolResponse(session_id, json_message);
 }
 
 void DevToolsProtocolClient::SendNotification(
@@ -58,19 +59,21 @@ void DevToolsProtocolClient::SendNotification(
   if (params)
     notification.Set(kParamsParam, params.release());
 
-  SendMessage(notification);
+  std::string json_message;
+  base::JSONWriter::Write(notification, &json_message);
+  SendRawNotification(json_message);
 }
 
 void DevToolsProtocolClient::SendSuccess(
     DevToolsCommandId command_id,
     scoped_ptr<base::DictionaryValue> params) {
   base::DictionaryValue response;
-  response.SetInteger(kIdParam, command_id);
+  response.SetInteger(kIdParam, command_id.call_id);
 
   response.Set(kResultParam,
       params ? params.release() : new base::DictionaryValue());
 
-  SendMessage(response);
+  SendMessage(command_id.session_id, response);
 }
 
 bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id,
@@ -80,10 +83,10 @@ bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id,
     return false;
   }
   base::DictionaryValue dict;
-  if (command_id == kNoId)
+  if (command_id.call_id == DevToolsCommandId::kNoId)
     dict.Set(kIdParam, base::Value::CreateNullValue());
   else
-    dict.SetInteger(kIdParam, command_id);
+    dict.SetInteger(kIdParam, command_id.call_id);
 
   base::DictionaryValue* error_object = new base::DictionaryValue();
   error_object->SetInteger(kErrorCodeParam, response.status());
@@ -91,7 +94,7 @@ bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id,
     error_object->SetString(kErrorMessageParam, response.message());
 
   dict.Set(kErrorParam, error_object);
-  SendMessage(dict);
+  SendMessage(command_id.session_id, dict);
   return true;
 }
 
diff --git a/content/browser/devtools/protocol/devtools_protocol_client.h b/content/browser/devtools/protocol/devtools_protocol_client.h
index 9297187..780bc74 100644
--- a/content/browser/devtools/protocol/devtools_protocol_client.h
+++ b/content/browser/devtools/protocol/devtools_protocol_client.h
@@ -10,16 +10,22 @@
 
 namespace content {
 
-using DevToolsCommandId = int;
-class DevToolsProtocolHandler;
+struct DevToolsCommandId {
+  static const int kNoId;
+
+  DevToolsCommandId(int call_id, int session_id)
+      : call_id(call_id), session_id(session_id) {}
+
+  int call_id;
+  int session_id;
+};
+
+class DevToolsProtocolDelegate;
 class DevToolsProtocolDispatcher;
+class DevToolsProtocolHandler;
 
 class DevToolsProtocolClient {
  public:
-  typedef base::Callback<void(const std::string& message)>
-      RawMessageCallback;
-  static const DevToolsCommandId kNoId;
-
   struct Response {
    public:
     static Response FallThrough();
@@ -46,12 +52,13 @@ class DevToolsProtocolClient {
   bool SendError(DevToolsCommandId command_id,
                  const Response& response);
 
-  // Sends message to client, the caller is presumed to properly
+  // Sends notification to client, the caller is presumed to properly
   // format the message. Do not use unless you must.
-  void SendRawMessage(const std::string& message);
+  void SendRawNotification(const std::string& message);
 
-  explicit DevToolsProtocolClient(
-      const RawMessageCallback& raw_message_callback);
+  void SendMessage(int session_id, const base::DictionaryValue& message);
+
+  explicit DevToolsProtocolClient(DevToolsProtocolDelegate* notifier);
   virtual ~DevToolsProtocolClient();
 
  protected:
@@ -63,9 +70,7 @@ class DevToolsProtocolClient {
  private:
   friend class DevToolsProtocolDispatcher;
 
-  void SendMessage(const base::DictionaryValue& message);
-
-  RawMessageCallback raw_message_callback_;
+  DevToolsProtocolDelegate* notifier_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsProtocolClient);
 };
 
diff --git a/content/browser/devtools/protocol/devtools_protocol_delegate.h b/content/browser/devtools/protocol/devtools_protocol_delegate.h
new file mode 100644
index 0000000..489020b
--- /dev/null
+++ b/content/browser/devtools/protocol/devtools_protocol_delegate.h
@@ -0,0 +1,22 @@
+// Copyright 2015 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_DELEGATE_H_
+#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DELEGATE_H_
+
+#include "content/common/content_export.h"
+
+namespace content {
+
+class CONTENT_EXPORT DevToolsProtocolDelegate {
+public:
+  virtual ~DevToolsProtocolDelegate() { }
+  virtual void SendProtocolResponse(int session_id,
+                                    const std::string& message) = 0;
+  virtual void SendProtocolNotification(const std::string& message) = 0;
+};
+
+} // content
+
+#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DELEGATE_H_
diff --git a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
index 6bce71e..6377be6 100755
--- a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
+++ b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
@@ -74,11 +74,11 @@ ${types}\
 
 class DevToolsProtocolDispatcher {
  public:
-  using Notifier = DevToolsProtocolClient::RawMessageCallback;
   using CommandHandler =
-      base::Callback<bool(int, scoped_ptr<base::DictionaryValue>)>;
+      base::Callback<bool(DevToolsCommandId,
+                          scoped_ptr<base::DictionaryValue>)>;
 
-  explicit DevToolsProtocolDispatcher(const Notifier& notifier);
+  explicit DevToolsProtocolDispatcher(DevToolsProtocolDelegate* notifier);
   ~DevToolsProtocolDispatcher();
 
   CommandHandler FindCommandHandler(const std::string& method);
@@ -91,7 +91,7 @@ ${setters}\
 
 ${methods}\
 
-  Notifier notifier_;
+  DevToolsProtocolDelegate* notifier_;
   DevToolsProtocolClient client_;
   CommandHandlers command_handlers_;
 ${fields}\
@@ -208,7 +208,7 @@ tmpl_client = string.Template("""\
 namespace ${domain} {
 class Client : public DevToolsProtocolClient {
  public:
-  explicit Client(const RawMessageCallback& raw_message_callback);
+  explicit Client(DevToolsProtocolDelegate* notifier);
   ~Client() override;
 
 ${methods}\
@@ -252,7 +252,7 @@ ${includes}\
 namespace content {
 
 DevToolsProtocolDispatcher::DevToolsProtocolDispatcher(
-    const Notifier& notifier)
+    DevToolsProtocolDelegate* notifier)
     : notifier_(notifier),
       client_(notifier),
       ${fields_init} {
@@ -405,8 +405,8 @@ tmpl_object_pass = string.Template(
 tmpl_client_impl = string.Template("""\
 namespace ${domain} {
 
-Client::Client(const RawMessageCallback& raw_message_callback)
-    : DevToolsProtocolClient(raw_message_callback) {
+Client::Client(DevToolsProtocolDelegate* notifier)
+    : DevToolsProtocolClient(notifier) {
 }
 
 Client::~Client() {
diff --git a/content/browser/devtools/protocol/input_handler.cc b/content/browser/devtools/protocol/input_handler.cc
index 0b4bdcc..c0def4e 100644
--- a/content/browser/devtools/protocol/input_handler.cc
+++ b/content/browser/devtools/protocol/input_handler.cc
@@ -398,8 +398,8 @@ void InputHandler::SynthesizeRepeatingScroll(
     DevToolsCommandId command_id) {
   if (!interaction_marker_name.empty()) {
     // TODO(alexclarke): Can we move this elsewhere? It doesn't really fit here.
-    TRACE_EVENT_COPY_ASYNC_BEGIN0("benchmark",
-                                  interaction_marker_name.c_str(), command_id);
+    TRACE_EVENT_COPY_ASYNC_BEGIN0("benchmark", interaction_marker_name.c_str(),
+                                  command_id.call_id);
   }
 
   host_->QueueSyntheticGesture(
@@ -417,8 +417,8 @@ void InputHandler::OnScrollFinished(
     DevToolsCommandId command_id,
     SyntheticGesture::Result result) {
   if (!interaction_marker_name.empty()) {
-    TRACE_EVENT_COPY_ASYNC_END0("benchmark",
-                                interaction_marker_name.c_str(), command_id);
+    TRACE_EVENT_COPY_ASYNC_END0("benchmark", interaction_marker_name.c_str(),
+                                command_id.call_id);
   }
 
   if (repeat_count > 0) {
diff --git a/content/browser/devtools/protocol/tracing_handler.cc b/content/browser/devtools/protocol/tracing_handler.cc
index 24890db..2fd8e4b 100644
--- a/content/browser/devtools/protocol/tracing_handler.cc
+++ b/content/browser/devtools/protocol/tracing_handler.cc
@@ -113,7 +113,7 @@ void TracingHandler::OnTraceDataCollected(const std::string& trace_fragment) {
   message.reserve(message.size() + trace_fragment.size() + messageSuffixSize);
   message += trace_fragment;
   message += "] } }";
-  client_->SendRawMessage(message);
+  client_->SendRawNotification(message);
 }
 
 void TracingHandler::OnTraceComplete() {
diff --git a/content/browser/devtools/render_frame_devtools_agent_host.cc b/content/browser/devtools/render_frame_devtools_agent_host.cc
index 1280168..3b6a207 100644
--- a/content/browser/devtools/render_frame_devtools_agent_host.cc
+++ b/content/browser/devtools/render_frame_devtools_agent_host.cc
@@ -86,7 +86,9 @@ class RenderFrameDevToolsAgentHost::FrameHostHolder {
   void Attach();
   void Reattach(FrameHostHolder* old);
   void Detach();
-  void DispatchProtocolMessage(int call_id, const std::string& message);
+  void DispatchProtocolMessage(int session_id,
+                               int call_id,
+                               const std::string& message);
   void InspectElement(int x, int y);
   void ProcessChunkedMessageFromAgent(const DevToolsMessageChunk& chunk);
   void Suspend();
@@ -95,15 +97,17 @@ class RenderFrameDevToolsAgentHost::FrameHostHolder {
  private:
   void GrantPolicy();
   void RevokePolicy();
-  void SendMessageToClient(const std::string& message);
+  void SendMessageToClient(int session_id, const std::string& message);
 
   RenderFrameDevToolsAgentHost* agent_;
   RenderFrameHostImpl* host_;
   bool attached_;
   bool suspended_;
   DevToolsMessageChunkProcessor chunk_processor_;
-  std::vector<std::string> pending_messages_;
-  std::map<int, std::string> sent_messages_;
+  // <session_id, message>
+  std::vector<std::pair<int, std::string>> pending_messages_;
+  // <call_id> -> <session_id, message>
+  std::map<int, std::pair<int, std::string>> sent_messages_;
 };
 
 RenderFrameDevToolsAgentHost::FrameHostHolder::FrameHostHolder(
@@ -126,7 +130,7 @@ RenderFrameDevToolsAgentHost::FrameHostHolder::~FrameHostHolder() {
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::Attach() {
   host_->Send(new DevToolsAgentMsg_Attach(
-      host_->GetRoutingID(), agent_->GetId()));
+      host_->GetRoutingID(), agent_->GetId(), agent_->session_id()));
   GrantPolicy();
   attached_ = true;
 }
@@ -136,10 +140,13 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::Reattach(
   if (old)
     chunk_processor_.set_state_cookie(old->chunk_processor_.state_cookie());
   host_->Send(new DevToolsAgentMsg_Reattach(
-      host_->GetRoutingID(), agent_->GetId(), chunk_processor_.state_cookie()));
+      host_->GetRoutingID(), agent_->GetId(), agent_->session_id(),
+      chunk_processor_.state_cookie()));
   if (old) {
-    for (const auto& pair : old->sent_messages_)
-      DispatchProtocolMessage(pair.first, pair.second);
+    for (const auto& pair : old->sent_messages_) {
+      DispatchProtocolMessage(pair.second.first, pair.first,
+                              pair.second.second);
+    }
   }
   GrantPolicy();
   attached_ = true;
@@ -179,10 +186,12 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::RevokePolicy() {
   }
 }
 void RenderFrameDevToolsAgentHost::FrameHostHolder::DispatchProtocolMessage(
-    int call_id, const std::string& message) {
+    int session_id,
+    int call_id,
+    const std::string& message) {
   host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-      host_->GetRoutingID(), message));
-  sent_messages_[call_id] = message;
+      host_->GetRoutingID(), session_id, message));
+  sent_messages_[call_id] = std::make_pair(session_id, message);
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::InspectElement(
@@ -199,12 +208,13 @@ RenderFrameDevToolsAgentHost::FrameHostHolder::ProcessChunkedMessageFromAgent(
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::SendMessageToClient(
+    int session_id,
     const std::string& message) {
   sent_messages_.erase(chunk_processor_.last_call_id());
   if (suspended_)
-    pending_messages_.push_back(message);
+    pending_messages_.push_back(std::make_pair(session_id, message));
   else
-    agent_->SendMessageToClient(message);
+    agent_->SendMessageToClient(session_id, message);
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::Suspend() {
@@ -213,9 +223,9 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::Suspend() {
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::Resume() {
   suspended_ = false;
-  for (const std::string& message : pending_messages_)
-    agent_->SendMessageToClient(message);
-  std::vector<std::string> empty;
+  for (const auto& pair : pending_messages_)
+    agent_->SendMessageToClient(pair.first, pair.second);
+  std::vector<std::pair<int, std::string>> empty;
   pending_messages_.swap(empty);
 }
 
@@ -326,10 +336,7 @@ RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(
           GetIOContext())),
       emulation_handler_(nullptr),
       frame_trace_recorder_(nullptr),
-      protocol_handler_(new DevToolsProtocolHandler(
-          this,
-          base::Bind(&RenderFrameDevToolsAgentHost::SendMessageToClient,
-                     base::Unretained(this)))),
+      protocol_handler_(new DevToolsProtocolHandler(this)),
       current_frame_crashed_(false) {
   DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
   dispatcher->SetDOMHandler(dom_handler_.get());
@@ -424,13 +431,13 @@ void RenderFrameDevToolsAgentHost::Detach() {
 bool RenderFrameDevToolsAgentHost::DispatchProtocolMessage(
     const std::string& message) {
   int call_id = 0;
-  if (protocol_handler_->HandleOptionalMessage(message, &call_id))
+  if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id))
     return true;
 
   if (current_)
-    current_->DispatchProtocolMessage(call_id, message);
+    current_->DispatchProtocolMessage(session_id(), call_id, message);
   if (pending_)
-    pending_->DispatchProtocolMessage(call_id, message);
+    pending_->DispatchProtocolMessage(session_id(), call_id, message);
   return true;
 }
 
diff --git a/content/browser/devtools/worker_devtools_agent_host.cc b/content/browser/devtools/worker_devtools_agent_host.cc
index 32cd668..d7be60a 100644
--- a/content/browser/devtools/worker_devtools_agent_host.cc
+++ b/content/browser/devtools/worker_devtools_agent_host.cc
@@ -21,7 +21,8 @@ void WorkerDevToolsAgentHost::Attach() {
     AttachToWorker();
   }
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
-    host->Send(new DevToolsAgentMsg_Attach(worker_id_.second, GetId()));
+    host->Send(
+        new DevToolsAgentMsg_Attach(worker_id_.second, GetId(), session_id()));
   OnAttachedStateChanged(true);
   DevToolsAgentHostImpl::NotifyCallbacks(this, true);
 }
@@ -45,12 +46,12 @@ bool WorkerDevToolsAgentHost::DispatchProtocolMessage(
     return true;
 
   int call_id;
-  if (protocol_handler_->HandleOptionalMessage(message, &call_id))
+  if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id))
     return true;
 
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) {
     host->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-        worker_id_.second, message));
+        worker_id_.second, session_id(), message));
   }
   return true;
 }
@@ -83,7 +84,8 @@ void WorkerDevToolsAgentHost::WorkerReadyForInspection() {
     AttachToWorker();
     if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) {
       host->Send(new DevToolsAgentMsg_Reattach(
-          worker_id_.second, GetId(), chunk_processor_.state_cookie()));
+          worker_id_.second, GetId(), session_id(),
+          chunk_processor_.state_cookie()));
     }
     OnAttachedStateChanged(true);
   }
@@ -101,10 +103,7 @@ void WorkerDevToolsAgentHost::WorkerDestroyed() {
   if (state_ == WORKER_INSPECTED) {
     DCHECK(IsAttached());
     // Client host is debugging this worker agent host.
-    base::Callback<void(const std::string&)> raw_message_callback(
-        base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient,
-                base::Unretained(this)));
-    devtools::inspector::Client inspector(raw_message_callback);
+    devtools::inspector::Client inspector(this);
     inspector.TargetCrashed(
         devtools::inspector::TargetCrashedParams::Create());
     DetachFromWorker();
@@ -117,15 +116,10 @@ bool WorkerDevToolsAgentHost::IsTerminated() {
   return state_ == WORKER_TERMINATED;
 }
 
-WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(
-    WorkerId worker_id)
-    : protocol_handler_(new DevToolsProtocolHandler(
-          this,
-          base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient,
-                     base::Unretained(this)))),
-      chunk_processor_(
-          base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient,
-                     base::Unretained(this))),
+WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(WorkerId worker_id)
+    : protocol_handler_(new DevToolsProtocolHandler(this)),
+      chunk_processor_(base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient,
+                                  base::Unretained(this))),
       state_(WORKER_UNINSPECTED),
       worker_id_(worker_id) {
   WorkerCreated();
diff --git a/content/child/shared_worker_devtools_agent.cc b/content/child/shared_worker_devtools_agent.cc
index 26a51ed..9b1996f 100644
--- a/content/child/shared_worker_devtools_agent.cc
+++ b/content/child/shared_worker_devtools_agent.cc
@@ -44,6 +44,7 @@ bool SharedWorkerDevToolsAgent::OnMessageReceived(const IPC::Message& message) {
 }
 
 void SharedWorkerDevToolsAgent::SendDevToolsMessage(
+    int session_id,
     int call_id,
     const blink::WebString& msg,
     const blink::WebString& state) {
@@ -55,6 +56,7 @@ void SharedWorkerDevToolsAgent::SendDevToolsMessage(
 
   if (message.length() < kMaxMessageChunkSize) {
     chunk.data.swap(message);
+    chunk.session_id = session_id;
     chunk.call_id = call_id;
     chunk.post_state = post_state;
     chunk.is_last = true;
@@ -65,6 +67,7 @@ void SharedWorkerDevToolsAgent::SendDevToolsMessage(
 
   for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
     chunk.is_last = pos + kMaxMessageChunkSize >= message.length();
+    chunk.session_id = chunk.is_last ? session_id : 0;
     chunk.call_id = chunk.is_last ? call_id : 0;
     chunk.post_state = chunk.is_last ? post_state : std::string();
     chunk.data = message.substr(pos, kMaxMessageChunkSize);
@@ -75,13 +78,15 @@ void SharedWorkerDevToolsAgent::SendDevToolsMessage(
   }
 }
 
-void SharedWorkerDevToolsAgent::OnAttach(const std::string& host_id) {
-  webworker_->attachDevTools(WebString::fromUTF8(host_id));
+void SharedWorkerDevToolsAgent::OnAttach(const std::string& host_id,
+                                         int session_id) {
+  webworker_->attachDevTools(WebString::fromUTF8(host_id), session_id);
 }
 
 void SharedWorkerDevToolsAgent::OnReattach(const std::string& host_id,
+                                           int session_id,
                                            const std::string& state) {
-  webworker_->reattachDevTools(WebString::fromUTF8(host_id),
+  webworker_->reattachDevTools(WebString::fromUTF8(host_id), session_id,
                                WebString::fromUTF8(state));
 }
 
@@ -90,8 +95,9 @@ void SharedWorkerDevToolsAgent::OnDetach() {
 }
 
 void SharedWorkerDevToolsAgent::OnDispatchOnInspectorBackend(
+    int session_id,
     const std::string& message) {
-  webworker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
+  webworker_->dispatchDevToolsMessage(session_id, WebString::fromUTF8(message));
 }
 
 bool SharedWorkerDevToolsAgent::Send(IPC::Message* message) {
diff --git a/content/child/shared_worker_devtools_agent.h b/content/child/shared_worker_devtools_agent.h
index 2d6a732..19b1ea9 100644
--- a/content/child/shared_worker_devtools_agent.h
+++ b/content/child/shared_worker_devtools_agent.h
@@ -27,15 +27,18 @@ class SharedWorkerDevToolsAgent {
 
   // Called on the Worker thread.
   bool OnMessageReceived(const IPC::Message& message);
-  void SendDevToolsMessage(int call_id,
+  void SendDevToolsMessage(int session_id,
+                           int call_id,
                            const blink::WebString& message,
                            const blink::WebString& post_state);
 
  private:
-  void OnAttach(const std::string& host_id);
-  void OnReattach(const std::string& host_id, const std::string& state);
+  void OnAttach(const std::string& host_id, int session_id);
+  void OnReattach(const std::string& host_id,
+                  int session_id,
+                  const std::string& state);
   void OnDetach();
-  void OnDispatchOnInspectorBackend(const std::string& message);
+  void OnDispatchOnInspectorBackend(int session_id, const std::string& message);
 
   bool Send(IPC::Message* message);
   const int route_id_;
diff --git a/content/common/devtools_messages.h b/content/common/devtools_messages.h
index f786a65..7edc617 100644
--- a/content/common/devtools_messages.h
+++ b/content/common/devtools_messages.h
@@ -58,12 +58,14 @@
 // Agent -> Client message chunk.
 //   |is_first| marks the first chunk, comes with the |message_size| for
 //   total message size.
-//   |is_last| marks the last chunk. |call_id| and |post_state| are optional
-//    parameters passed with the last chunk of the protocol response.
+//   |is_last| marks the last chunk. |call_id|, |session_id| and |post_state|
+//   are optional parameters passed with the last chunk of the protocol
+//   response.
 IPC_STRUCT_BEGIN(DevToolsMessageChunk)
   IPC_STRUCT_MEMBER(bool, is_first)
   IPC_STRUCT_MEMBER(bool, is_last)
   IPC_STRUCT_MEMBER(int, message_size)
+  IPC_STRUCT_MEMBER(int, session_id)
   IPC_STRUCT_MEMBER(int, call_id)
   IPC_STRUCT_MEMBER(std::string, data)
   IPC_STRUCT_MEMBER(std::string, post_state)
@@ -77,20 +79,23 @@ IPC_MESSAGE_ROUTED1(DevToolsClientMsg_DispatchOnInspectorFrontend,
 // These are messages sent from DevToolsClient to DevToolsAgent through the
 // browser.
 // Tells agent that there is a client host connected to it.
-IPC_MESSAGE_ROUTED1(DevToolsAgentMsg_Attach,
-                    std::string /* host_id */)
+IPC_MESSAGE_ROUTED2(DevToolsAgentMsg_Attach,
+                    std::string /* host_id */,
+                    int /* session_id */)
 
 // Tells agent that a client host was disconnected from another agent and
 // connected to this one.
-IPC_MESSAGE_ROUTED2(DevToolsAgentMsg_Reattach,
+IPC_MESSAGE_ROUTED3(DevToolsAgentMsg_Reattach,
                     std::string /* host_id */,
+                    int /* session_id */,
                     std::string /* agent_state */)
 
 // Tells agent that there is no longer a client host connected to it.
 IPC_MESSAGE_ROUTED0(DevToolsAgentMsg_Detach)
 
 // WebKit-level transport.
-IPC_MESSAGE_ROUTED1(DevToolsAgentMsg_DispatchOnInspectorBackend,
+IPC_MESSAGE_ROUTED2(DevToolsAgentMsg_DispatchOnInspectorBackend,
+                    int /* session_id */,
                     std::string /* message */)
 
 // Inspect element with the given coordinates.
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index 824aad8..d970465 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -544,6 +544,7 @@
       'browser/devtools/forwarding_agent_host.h',
       'browser/devtools/protocol/color_picker.cc',
       'browser/devtools/protocol/color_picker.h',
+      'browser/devtools/protocol/devtools_protocol_delegate.h',
       'browser/devtools/protocol/devtools_protocol_client.cc',
       'browser/devtools/protocol/devtools_protocol_client.h',
       'browser/devtools/protocol/dom_handler.cc',
diff --git a/content/renderer/devtools/devtools_agent.cc b/content/renderer/devtools/devtools_agent.cc
index 3b2f47e..55b4c6b 100644
--- a/content/renderer/devtools/devtools_agent.cc
+++ b/content/renderer/devtools/devtools_agent.cc
@@ -101,12 +101,12 @@ void DevToolsAgent::WidgetWillClose() {
   ContinueProgram();
 }
 
-void DevToolsAgent::sendProtocolMessage(
-    int call_id,
-    const blink::WebString& message,
-    const blink::WebString& state_cookie) {
-  SendChunkedProtocolMessage(
-      this, routing_id(), call_id, message.utf8(), state_cookie.utf8());
+void DevToolsAgent::sendProtocolMessage(int session_id,
+                                        int call_id,
+                                        const blink::WebString& message,
+                                        const blink::WebString& state_cookie) {
+  SendChunkedProtocolMessage(this, routing_id(), session_id, call_id,
+                             message.utf8(), state_cookie.utf8());
 }
 
 blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
@@ -157,18 +157,19 @@ DevToolsAgent* DevToolsAgent::FromRoutingId(int routing_id) {
 }
 
 // static
-void DevToolsAgent::SendChunkedProtocolMessage(
-    IPC::Sender* sender,
-    int routing_id,
-    int call_id,
-    const std::string& message,
-    const std::string& post_state) {
+void DevToolsAgent::SendChunkedProtocolMessage(IPC::Sender* sender,
+                                               int routing_id,
+                                               int session_id,
+                                               int call_id,
+                                               const std::string& message,
+                                               const std::string& post_state) {
   DevToolsMessageChunk chunk;
   chunk.message_size = message.size();
   chunk.is_first = true;
 
   if (message.length() < kMaxMessageChunkSize) {
     chunk.data = message;
+    chunk.session_id = session_id;
     chunk.call_id = call_id;
     chunk.post_state = post_state;
     chunk.is_last = true;
@@ -179,6 +180,7 @@ void DevToolsAgent::SendChunkedProtocolMessage(
 
   for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
     chunk.is_last = pos + kMaxMessageChunkSize >= message.length();
+    chunk.session_id = chunk.is_last ? session_id : 0;
     chunk.call_id = chunk.is_last ? call_id : 0;
     chunk.post_state = chunk.is_last ? post_state : std::string();
     chunk.data = message.substr(pos, kMaxMessageChunkSize);
@@ -189,19 +191,20 @@ void DevToolsAgent::SendChunkedProtocolMessage(
   }
 }
 
-void DevToolsAgent::OnAttach(const std::string& host_id) {
+void DevToolsAgent::OnAttach(const std::string& host_id, int session_id) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->attach(WebString::fromUTF8(host_id));
+    web_agent->attach(WebString::fromUTF8(host_id), session_id);
     is_attached_ = true;
   }
 }
 
 void DevToolsAgent::OnReattach(const std::string& host_id,
+                               int session_id,
                                const std::string& agent_state) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->reattach(WebString::fromUTF8(host_id),
+    web_agent->reattach(WebString::fromUTF8(host_id), session_id,
                         WebString::fromUTF8(agent_state));
     is_attached_ = true;
   }
@@ -215,11 +218,13 @@ void DevToolsAgent::OnDetach() {
   }
 }
 
-void DevToolsAgent::OnDispatchOnInspectorBackend(const std::string& message) {
+void DevToolsAgent::OnDispatchOnInspectorBackend(int session_id,
+                                                 const std::string& message) {
   TRACE_EVENT0("devtools", "DevToolsAgent::OnDispatchOnInspectorBackend");
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent)
-    web_agent->dispatchOnInspectorBackend(WebString::fromUTF8(message));
+    web_agent->dispatchOnInspectorBackend(session_id,
+                                          WebString::fromUTF8(message));
 }
 
 void DevToolsAgent::OnInspectElement(int x, int y) {
diff --git a/content/renderer/devtools/devtools_agent.h b/content/renderer/devtools/devtools_agent.h
index cbdccd5..f4163d7 100644
--- a/content/renderer/devtools/devtools_agent.h
+++ b/content/renderer/devtools/devtools_agent.h
@@ -33,12 +33,12 @@ class CONTENT_EXPORT DevToolsAgent
   // Returns agent instance for its routing id.
   static DevToolsAgent* FromRoutingId(int routing_id);
 
-  static void SendChunkedProtocolMessage(
-      IPC::Sender* sender,
-      int routing_id,
-      int call_id,
-      const std::string& message,
-      const std::string& post_state);
+  static void SendChunkedProtocolMessage(IPC::Sender* sender,
+                                         int routing_id,
+                                         int session_id,
+                                         int call_id,
+                                         const std::string& message,
+                                         const std::string& post_state);
 
   blink::WebDevToolsAgent* GetWebAgent();
 
@@ -55,7 +55,8 @@ class CONTENT_EXPORT DevToolsAgent
   void WidgetWillClose() override;
 
   // WebDevToolsAgentClient implementation.
-  void sendProtocolMessage(int call_id,
+  void sendProtocolMessage(int session_id,
+                           int call_id,
                            const blink::WebString& response,
                            const blink::WebString& state) override;
   blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
@@ -66,11 +67,12 @@ class CONTENT_EXPORT DevToolsAgent
   void enableTracing(const blink::WebString& category_filter) override;
   void disableTracing() override;
 
-  void OnAttach(const std::string& host_id);
+  void OnAttach(const std::string& host_id, int session_id);
   void OnReattach(const std::string& host_id,
+                  int session_id,
                   const std::string& agent_state);
   void OnDetach();
-  void OnDispatchOnInspectorBackend(const std::string& message);
+  void OnDispatchOnInspectorBackend(int session_id, const std::string& message);
   void OnInspectElement(int x, int y);
   void ContinueProgram();
   void OnSetupDevToolsClient(const std::string& compatibility_script);
diff --git a/content/renderer/devtools/devtools_agent_filter.cc b/content/renderer/devtools/devtools_agent_filter.cc
index e1b3af0..94b9e0d4 100644
--- a/content/renderer/devtools/devtools_agent_filter.cc
+++ b/content/renderer/devtools/devtools_agent_filter.cc
@@ -60,6 +60,7 @@ bool DevToolsAgentFilter::OnMessageReceived(const IPC::Message& message) {
 DevToolsAgentFilter::~DevToolsAgentFilter() {}
 
 void DevToolsAgentFilter::OnDispatchOnInspectorBackend(
+    int session_id,
     const std::string& message) {
   if (embedded_worker_routes_.find(current_routing_id_) !=
       embedded_worker_routes_.end()) {
@@ -69,7 +70,7 @@ void DevToolsAgentFilter::OnDispatchOnInspectorBackend(
   if (WebDevToolsAgent::shouldInterruptForMessage(
           WebString::fromUTF8(message))) {
     WebDevToolsAgent::interruptAndDispatch(
-        new MessageImpl(message, current_routing_id_));
+        session_id, new MessageImpl(message, current_routing_id_));
   }
 
 }
diff --git a/content/renderer/devtools/devtools_agent_filter.h b/content/renderer/devtools/devtools_agent_filter.h
index c8ba687..9113ae2 100644
--- a/content/renderer/devtools/devtools_agent_filter.h
+++ b/content/renderer/devtools/devtools_agent_filter.h
@@ -43,7 +43,7 @@ class DevToolsAgentFilter : public IPC::MessageFilter {
   ~DevToolsAgentFilter() override;
 
  private:
-  void OnDispatchOnInspectorBackend(const std::string& message);
+  void OnDispatchOnInspectorBackend(int session_id, const std::string& message);
 
   // Called on IO thread
   void AddEmbeddedWorkerRoute(int32 routing_id);
diff --git a/content/renderer/render_view_browsertest.cc b/content/renderer/render_view_browsertest.cc
index 724c8e8..85a8ae7 100644
--- a/content/renderer/render_view_browsertest.cc
+++ b/content/renderer/render_view_browsertest.cc
@@ -338,7 +338,7 @@ class DevToolsAgentTest : public RenderViewImplTest {
  public:
   void Attach() {
     std::string host_id = "host_id";
-    agent()->OnAttach(host_id);
+    agent()->OnAttach(host_id, 17);
   }
 
   void Detach() {
@@ -350,7 +350,7 @@ class DevToolsAgentTest : public RenderViewImplTest {
   }
 
   void DispatchDevToolsMessage(const std::string& message) {
-    agent()->OnDispatchOnInspectorBackend(message);
+    agent()->OnDispatchOnInspectorBackend(17, message);
   }
 
   void CloseWhilePaused() {
diff --git a/content/renderer/service_worker/embedded_worker_devtools_agent.cc b/content/renderer/service_worker/embedded_worker_devtools_agent.cc
index e1c640a..a099729 100644
--- a/content/renderer/service_worker/embedded_worker_devtools_agent.cc
+++ b/content/renderer/service_worker/embedded_worker_devtools_agent.cc
@@ -40,13 +40,15 @@ bool EmbeddedWorkerDevToolsAgent::OnMessageReceived(
   return handled;
 }
 
-void EmbeddedWorkerDevToolsAgent::OnAttach(const std::string& host_id) {
-  webworker_->attachDevTools(WebString::fromUTF8(host_id));
+void EmbeddedWorkerDevToolsAgent::OnAttach(const std::string& host_id,
+                                           int session_id) {
+  webworker_->attachDevTools(WebString::fromUTF8(host_id), session_id);
 }
 
 void EmbeddedWorkerDevToolsAgent::OnReattach(const std::string& host_id,
+                                             int session_id,
                                              const std::string& state) {
-  webworker_->reattachDevTools(WebString::fromUTF8(host_id),
+  webworker_->reattachDevTools(WebString::fromUTF8(host_id), session_id,
                                WebString::fromUTF8(state));
 }
 
@@ -55,8 +57,9 @@ void EmbeddedWorkerDevToolsAgent::OnDetach() {
 }
 
 void EmbeddedWorkerDevToolsAgent::OnDispatchOnInspectorBackend(
+    int session_id,
     const std::string& message) {
-  webworker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
+  webworker_->dispatchDevToolsMessage(session_id, WebString::fromUTF8(message));
 }
 
 }  // namespace content
diff --git a/content/renderer/service_worker/embedded_worker_devtools_agent.h b/content/renderer/service_worker/embedded_worker_devtools_agent.h
index 97c1582..c63081e 100644
--- a/content/renderer/service_worker/embedded_worker_devtools_agent.h
+++ b/content/renderer/service_worker/embedded_worker_devtools_agent.h
@@ -30,10 +30,12 @@ class EmbeddedWorkerDevToolsAgent : public IPC::Listener {
   bool OnMessageReceived(const IPC::Message& message) override;
 
  private:
-  void OnAttach(const std::string& host_id);
-  void OnReattach(const std::string& host_id, const std::string& state);
+  void OnAttach(const std::string& host_id, int session_id);
+  void OnReattach(const std::string& host_id,
+                  int session_id,
+                  const std::string& state);
   void OnDetach();
-  void OnDispatchOnInspectorBackend(const std::string& message);
+  void OnDispatchOnInspectorBackend(int session_id, const std::string& message);
 
   blink::WebEmbeddedWorker* webworker_;
   int route_id_;
diff --git a/content/renderer/service_worker/service_worker_context_client.cc b/content/renderer/service_worker/service_worker_context_client.cc
index cadeb7c..7a5e37e 100644
--- a/content/renderer/service_worker/service_worker_context_client.cc
+++ b/content/renderer/service_worker/service_worker_context_client.cc
@@ -468,12 +468,13 @@ void ServiceWorkerContextClient::reportConsoleMessage(
 }
 
 void ServiceWorkerContextClient::sendDevToolsMessage(
+    int session_id,
     int call_id,
     const blink::WebString& message,
     const blink::WebString& state_cookie) {
   DevToolsAgent::SendChunkedProtocolMessage(
-      sender_.get(), worker_devtools_agent_route_id_,
-      call_id, message.utf8(), state_cookie.utf8());
+      sender_.get(), worker_devtools_agent_route_id_, session_id, call_id,
+      message.utf8(), state_cookie.utf8());
 }
 
 void ServiceWorkerContextClient::didHandleActivateEvent(
diff --git a/content/renderer/service_worker/service_worker_context_client.h b/content/renderer/service_worker/service_worker_context_client.h
index bb7b820..14bec2d 100644
--- a/content/renderer/service_worker/service_worker_context_client.h
+++ b/content/renderer/service_worker/service_worker_context_client.h
@@ -117,7 +117,8 @@ class ServiceWorkerContextClient
                             const blink::WebString& message,
                             int line_number,
                             const blink::WebString& source_url) override;
-  void sendDevToolsMessage(int call_id,
+  void sendDevToolsMessage(int session_id,
+                           int call_id,
                            const blink::WebString& message,
                            const blink::WebString& state) override;
   void didHandleActivateEvent(int request_id,
diff --git a/content/renderer/shared_worker/embedded_shared_worker_stub.cc b/content/renderer/shared_worker/embedded_shared_worker_stub.cc
index 934dade..975bab9 100644
--- a/content/renderer/shared_worker/embedded_shared_worker_stub.cc
+++ b/content/renderer/shared_worker/embedded_shared_worker_stub.cc
@@ -253,10 +253,12 @@ EmbeddedSharedWorkerStub::createServiceWorkerNetworkProvider(
 }
 
 void EmbeddedSharedWorkerStub::sendDevToolsMessage(
+    int session_id,
     int call_id,
     const blink::WebString& message,
     const blink::WebString& state) {
-  worker_devtools_agent_->SendDevToolsMessage(call_id, message, state);
+  worker_devtools_agent_->SendDevToolsMessage(
+      session_id, call_id, message, state);
 }
 
 void EmbeddedSharedWorkerStub::Shutdown() {
diff --git a/content/renderer/shared_worker/embedded_shared_worker_stub.h b/content/renderer/shared_worker/embedded_shared_worker_stub.h
index 9f2c6c0..a7d62d0 100644
--- a/content/renderer/shared_worker/embedded_shared_worker_stub.h
+++ b/content/renderer/shared_worker/embedded_shared_worker_stub.h
@@ -70,7 +70,8 @@ class EmbeddedSharedWorkerStub : public IPC::Listener,
       const blink::WebSecurityOrigin& origin) override;
   blink::WebServiceWorkerNetworkProvider* createServiceWorkerNetworkProvider(
       blink::WebDataSource*) override;
-  void sendDevToolsMessage(int call_id,
+  void sendDevToolsMessage(int session_id,
+                           int call_id,
                            const blink::WebString& message,
                            const blink::WebString& state) override;