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

content/renderer/devtools/devtools_agent.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/renderer/devtools/devtools_agent.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 83 matching lines @@
   if (message.type() == FrameMsg_Navigate::ID)
     ContinueProgram();  // Don't want to swallow the message.
 
   return handled;
 }
 
 void DevToolsAgent::WidgetWillClose() {
   ContinueProgram();
 }
 
-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());
+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());
 }
 
 blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
     DevToolsAgent::createClientMessageLoop() {
   return new WebKitClientMessageLoopImpl();
 }
 
 void DevToolsAgent::willEnterDebugLoop() {
   paused_ = true;
   if (RenderWidget* widget = frame_->GetRenderWidget())
@@ skipping 24 matching lines @@
 // static
 DevToolsAgent* DevToolsAgent::FromRoutingId(int routing_id) {
   IdToAgentMap::iterator it = g_agent_for_routing_id.Get().find(routing_id);
   if (it != g_agent_for_routing_id.Get().end()) {
     return it->second;
   }
   return NULL;
 }
 
 // static
-void DevToolsAgent::SendChunkedProtocolMessage(IPC::Sender* sender,
-                                               int routing_id,
-                                               int session_id,
-                                               int call_id,
-                                               const std::string& message,
-                                               const std::string& post_state) {
+void DevToolsAgent::SendChunkedProtocolMessage(
+    IPC::Sender* sender,
+    int routing_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;
     sender->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
                      routing_id, chunk));
     return;
   }
 
   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);
     sender->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
                      routing_id, chunk));
     chunk.is_first = false;
     chunk.message_size = 0;
   }
 }
 
-void DevToolsAgent::OnAttach(const std::string& host_id, int session_id) {
+void DevToolsAgent::OnAttach(const std::string& host_id) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->attach(WebString::fromUTF8(host_id), session_id);
+    web_agent->attach(WebString::fromUTF8(host_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), session_id,
+    web_agent->reattach(WebString::fromUTF8(host_id),
                         WebString::fromUTF8(agent_state));
     is_attached_ = true;
   }
 }
 
 void DevToolsAgent::OnDetach() {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
     web_agent->detach();
     is_attached_ = false;
   }
 }
 
-void DevToolsAgent::OnDispatchOnInspectorBackend(int session_id,
-                                                 const std::string& message) {
+void DevToolsAgent::OnDispatchOnInspectorBackend(const std::string& message) {
   TRACE_EVENT0("devtools", "DevToolsAgent::OnDispatchOnInspectorBackend");
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent)
-    web_agent->dispatchOnInspectorBackend(session_id,
-                                          WebString::fromUTF8(message));
+    web_agent->dispatchOnInspectorBackend(WebString::fromUTF8(message));
 }
 
-void DevToolsAgent::OnInspectElement(const std::string& host_id,
-                                     int session_id,
-                                     int x,
-                                     int y) {
+void DevToolsAgent::OnInspectElement(
+    const std::string& host_id, int x, int y) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->attach(WebString::fromUTF8(host_id), session_id);
+    web_agent->attach(WebString::fromUTF8(host_id));
     web_agent->inspectElementAt(WebPoint(x, y));
     is_attached_ = true;
   }
 }
 
 void DevToolsAgent::AddMessageToConsole(ConsoleMessageLevel level,
                                         const std::string& message) {
   WebLocalFrame* web_frame = frame_->GetWebFrame();
   if (!web_frame)
     return;
@@ skipping 36 matching lines @@
 WebDevToolsAgent* DevToolsAgent::GetWebAgent() {
   WebLocalFrame* web_frame = frame_->GetWebFrame();
   return web_frame ? web_frame->devToolsAgent() : nullptr;
 }
 
 bool DevToolsAgent::IsAttached() {
   return is_attached_;
 }
 
 }  // namespace content