[DevTools] Filter any messages from previous sessions in DevToolsAgentHostImpl

content/browser/devtools/protocol/tracing_handler.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/devtools/protocol/tracing_handler.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 95 matching lines @@
 
 void TracingHandler::OnTraceDataCollected(const std::string& trace_fragment) {
   // Hand-craft protocol notification message so we can substitute JSON
   // that we already got as string as a bare object, not a quoted string.
   std::string message(
       "{ \"method\": \"Tracing.dataCollected\", \"params\": { \"value\": [");
   const size_t messageSuffixSize = 10;
   message.reserve(message.size() + trace_fragment.size() + messageSuffixSize);
   message += trace_fragment;
   message += "] } }";
-  client_->SendRawMessage(message);
+  client_->SendRawMessage(0, message);
 }
 
 void TracingHandler::OnTraceComplete() {
   client_->TracingComplete(TracingCompleteParams::Create());
 }
 
 void TracingHandler::OnTraceToStreamComplete(const std::string& stream_handle) {
   client_->TracingComplete(
       TracingCompleteParams::Create()->set_stream(stream_handle));
 }
 
-Response TracingHandler::Start(DevToolsCommandId command_id,
+Response TracingHandler::Start(int session_id,
+                               DevToolsCommandId command_id,
                                const std::string* categories,
                                const std::string* options,
                                const double* buffer_usage_reporting_interval,
                                const std::string* transfer_mode) {
   if (IsRecording())
     return Response::InternalError("Tracing is already started");
 
   did_initiate_recording_ = true;
   return_as_stream_ =
       transfer_mode && *transfer_mode == start::kTransferModeReturnAsStream;
   base::trace_event::TraceConfig trace_config(
       categories ? *categories : std::string(),
       options ? *options : std::string());
   if (buffer_usage_reporting_interval)
     SetupTimer(*buffer_usage_reporting_interval);
 
   // If inspected target is a render process Tracing.start will be handled by
   // tracing agent in the renderer.
   if (target_ == Renderer) {
     TracingController::GetInstance()->EnableRecording(
         trace_config,
         TracingController::EnableRecordingDoneCallback());
     return Response::FallThrough();
   }
 
   TracingController::GetInstance()->EnableRecording(
       trace_config,
       base::Bind(&TracingHandler::OnRecordingEnabled,
-                 weak_factory_.GetWeakPtr(),
-                 command_id));
+                 weak_factory_.GetWeakPtr(), session_id, command_id));
   return Response::OK();
 }
 
-Response TracingHandler::End(DevToolsCommandId command_id) {
+Response TracingHandler::End(int session_id, DevToolsCommandId command_id) {
   // Startup tracing triggered by --trace-config-file is a special case, where
   // tracing is started automatically upon browser startup and can be stopped
   // via DevTools.
   if (!did_initiate_recording_ && !IsStartupTracingActive())
     return Response::InternalError("Tracing is not started");
 
   scoped_refptr<TracingController::TraceDataSink> proxy;
   if (return_as_stream_) {
     proxy = new DevToolsStreamTraceSink(
         weak_factory_.GetWeakPtr(), io_context_->CreateTempFileBackedStream());
   } else {
     proxy = new DevToolsTraceSinkProxy(weak_factory_.GetWeakPtr());
   }
   DisableRecording(proxy);
   // If inspected target is a render process Tracing.end will be handled by
   // tracing agent in the renderer.
   return target_ == Renderer ? Response::FallThrough() : Response::OK();
 }
 
-Response TracingHandler::GetCategories(DevToolsCommandId command_id) {
+Response TracingHandler::GetCategories(int session_id,
+                                       DevToolsCommandId command_id) {
   TracingController::GetInstance()->GetCategories(
       base::Bind(&TracingHandler::OnCategoriesReceived,
-                 weak_factory_.GetWeakPtr(),
-                 command_id));
+                 weak_factory_.GetWeakPtr(), session_id, command_id));
   return Response::OK();
 }
 
-void TracingHandler::OnRecordingEnabled(DevToolsCommandId command_id) {
-  client_->SendStartResponse(command_id, StartResponse::Create());
+void TracingHandler::OnRecordingEnabled(int session_id,
+                                        DevToolsCommandId command_id) {
+  client_->SendStartResponse(session_id, command_id, StartResponse::Create());
 }
 
 void TracingHandler::OnBufferUsage(float percent_full,
                                    size_t approximate_event_count) {
   // TODO(crbug426117): remove set_value once all clients have switched to
   // the new interface of the event.
   client_->BufferUsage(BufferUsageParams::Create()
                            ->set_value(percent_full)
                            ->set_percent_full(percent_full)
                            ->set_event_count(approximate_event_count));
 }
 
 void TracingHandler::OnCategoriesReceived(
+    int session_id,
     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_id,
+  client_->SendGetCategoriesResponse(
+      session_id, command_id,
       GetCategoriesResponse::Create()->set_categories(categories));
 }
 
-Response TracingHandler::RequestMemoryDump(DevToolsCommandId command_id) {
+Response TracingHandler::RequestMemoryDump(int session_id,
+                                           DevToolsCommandId command_id) {
   if (!IsRecording())
     return Response::InternalError("Tracing is not started");
 
   base::trace_event::MemoryDumpManager::GetInstance()->RequestGlobalDump(
       base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
       base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
       base::Bind(&TracingHandler::OnMemoryDumpFinished,
-                 weak_factory_.GetWeakPtr(), command_id));
+                 weak_factory_.GetWeakPtr(), session_id, command_id));
   return Response::OK();
 }
 
-void TracingHandler::OnMemoryDumpFinished(DevToolsCommandId command_id,
+void TracingHandler::OnMemoryDumpFinished(int session_id,
+                                          DevToolsCommandId command_id,
                                           uint64 dump_guid,
                                           bool success) {
   client_->SendRequestMemoryDumpResponse(
-      command_id,
+      session_id, command_id,
       RequestMemoryDumpResponse::Create()
           ->set_dump_guid(base::StringPrintf("0x%" PRIx64, dump_guid))
           ->set_success(success));
 }
 
 void TracingHandler::SetupTimer(double usage_reporting_interval) {
   if (usage_reporting_interval == 0) return;
 
   if (usage_reporting_interval < kMinimumReportingInterval)
       usage_reporting_interval = kMinimumReportingInterval;
@@ skipping 22 matching lines @@
 }
 
 bool TracingHandler::IsStartupTracingActive() {
   return ::tracing::TraceConfigFile::GetInstance()->IsEnabled() &&
       TracingController::GetInstance()->IsRecording();
 }
 
 }  // namespace tracing
 }  // namespace devtools
 }  // namespace content