Revert of [DevTools] Filter any messages from previous sessions in DevToolsAgentHostImpl

content/browser/devtools/devtools_agent_host_impl.cc

 // Copyright (c) 2012 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_agent_host_impl.h"
 
 #include <map>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 58 matching lines @@
       SharedWorkerDevToolsManager::GetInstance()
           ->GetDevToolsAgentHostForWorker(worker_process_id,
                                           worker_route_id)) {
     return host;
   }
   return ServiceWorkerDevToolsManager::GetInstance()
       ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id);
 }
 
 DevToolsAgentHostImpl::DevToolsAgentHostImpl()
-    : id_(base::GenerateGUID()), session_id_(0), client_(NULL) {
+    : id_(base::GenerateGUID()),
+      client_(NULL) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_instances.Get()[id_] = this;
 }
 
 DevToolsAgentHostImpl::~DevToolsAgentHostImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_instances.Get().erase(g_instances.Get().find(id_));
 }
 
 // static
 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForId(
     const std::string& id) {
   if (g_instances == NULL)
     return NULL;
   Instances::iterator it = g_instances.Get().find(id);
   if (it == g_instances.Get().end())
     return NULL;
   return it->second;
 }
 
 // static
 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::Create(
     DevToolsExternalAgentProxyDelegate* delegate) {
   return new ForwardingAgentHost(delegate);
 }
 
 void DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) {
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
-  ++session_id_;
   if (client_) {
     client_->AgentHostClosed(this, true);
     InnerDetach();
   }
   client_ = client;
   Attach();
 }
 
 void DevToolsAgentHostImpl::DetachClient() {
   if (!client_)
@@ skipping 27 matching lines @@
 WebContents* DevToolsAgentHostImpl::GetWebContents() {
   return NULL;
 }
 
 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;
 
   scoped_refptr<DevToolsAgentHostImpl> protect(this);
   // Clear |client_| before notifying it.
   DevToolsAgentHostClient* client = client_;
   client_ = NULL;
   client->AgentHostClosed(this, false);
 }
 
-void DevToolsAgentHostImpl::SendMessageToClient(int session_id,
-                                                const std::string& message) {
+void DevToolsAgentHostImpl::SendMessageToClient(const std::string& message) {
   if (!client_)
     return;
-  // Filter any messages from previous sessions.
-  if (session_id != session_id_)
-    return;
   client_->DispatchProtocolMessage(this, message);
 }
 
 // static
 void DevToolsAgentHost::DetachAllClients() {
   if (g_instances == NULL)
     return;
 
   // Make a copy, since detaching may lead to agent destruction, which
   // removes it from the instances.
@@ skipping 62 matching lines @@
 
 void DevToolsMessageChunkProcessor::ProcessChunkedMessageFromAgent(
     const DevToolsMessageChunk& chunk) {
   if (chunk.is_last && !chunk.post_state.empty())
     state_cookie_ = chunk.post_state;
   if (chunk.is_last)
     last_call_id_ = chunk.call_id;
 
   if (chunk.is_first && chunk.is_last) {
     CHECK(message_buffer_size_ == 0);
-    callback_.Run(chunk.session_id, chunk.data);
+    callback_.Run(chunk.data);
     return;
   }
 
   if (chunk.is_first) {
     message_buffer_ = std::string();
     message_buffer_.reserve(chunk.message_size);
     message_buffer_size_ = chunk.message_size;
   }
 
   CHECK(message_buffer_.size() + chunk.data.size() <=
       message_buffer_size_);
   message_buffer_.append(chunk.data);
 
   if (chunk.is_last) {
     CHECK(message_buffer_.size() == message_buffer_size_);
-    callback_.Run(chunk.session_id, message_buffer_);
+    callback_.Run(message_buffer_);
     message_buffer_ = std::string();
     message_buffer_size_ = 0;
   }
 }
 
 }  // namespace content