DevTools: use explicit IPC messages for enabling/disabling tracing instead of intercepting protocol…

content/browser/devtools/devtools_tracing_handler.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_tracing_handler.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 47 matching lines @@
     : weak_factory_(this), target_(target), is_recording_(false) {
   RegisterCommandHandler(devtools::Tracing::start::kName,
                          base::Bind(&DevToolsTracingHandler::OnStart,
                                     base::Unretained(this)));
   RegisterCommandHandler(devtools::Tracing::end::kName,
                          base::Bind(&DevToolsTracingHandler::OnEnd,
                                     base::Unretained(this)));
   RegisterCommandHandler(devtools::Tracing::getCategories::kName,
                          base::Bind(&DevToolsTracingHandler::OnGetCategories,
                                     base::Unretained(this)));
-  RegisterNotificationHandler(devtools::Tracing::started::kName,
-                         base::Bind(&DevToolsTracingHandler::OnTracingStarted,
-                                    base::Unretained(this)));
-  RegisterNotificationHandler(devtools::Tracing::stopped::kName,
-                         base::Bind(&DevToolsTracingHandler::OnTracingStopped,
-                                    base::Unretained(this)));
 }
 
 DevToolsTracingHandler::~DevToolsTracingHandler() {
 }
 
 void DevToolsTracingHandler::BeginReadingRecordingResult(
     const base::FilePath& path) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReadFile, path,
@@ skipping 63 matching lines @@
     } else if (*iter == kEnableSampling) {
       ret.enable_sampling = true;
     }
   }
   return ret;
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 DevToolsTracingHandler::OnStart(
     scoped_refptr<DevToolsProtocol::Command> command) {
+  // If inspected target is a render process Tracing.start will be handled by
+  // tracing agent in the renderer.
+  if (target_ == Renderer)
+    return NULL;
+
   is_recording_ = true;
 
   std::string categories;
   base::debug::TraceOptions options;
   double usage_reporting_interval = 0.0;
 
   base::DictionaryValue* params = command->params();
   if (params) {
     params->GetString(devtools::Tracing::start::kParamCategories, &categories);
     std::string options_param;
     if (params->GetString(devtools::Tracing::start::kParamOptions,
                           &options_param)) {
       options = TraceOptionsFromString(options_param);
     }
     params->GetDouble(
         devtools::Tracing::start::kParamBufferUsageReportingInterval,
         &usage_reporting_interval);
   }
 
   SetupTimer(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(
-        base::debug::CategoryFilter(categories),
-        options,
-        TracingController::EnableRecordingDoneCallback());
-    return NULL;
-  }
-
   TracingController::GetInstance()->EnableRecording(
       base::debug::CategoryFilter(categories),
       options,
       base::Bind(&DevToolsTracingHandler::OnRecordingEnabled,
                  weak_factory_.GetWeakPtr(),
                  command));
   return command->AsyncResponsePromise();
 }
 
 void DevToolsTracingHandler::SetupTimer(double usage_reporting_interval) {
@@ skipping 23 matching lines @@
 
 void DevToolsTracingHandler::OnBufferUsage(float usage) {
   base::DictionaryValue* params = new base::DictionaryValue();
   params->SetDouble(devtools::Tracing::bufferUsage::kParamValue, usage);
   SendNotification(devtools::Tracing::bufferUsage::kName, params);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 DevToolsTracingHandler::OnEnd(
     scoped_refptr<DevToolsProtocol::Command> command) {
+  // If inspected target is a render process Tracing.end will be handled by
+  // tracing agent in the renderer.
+  if (target_ == Renderer)
+    return NULL;
   DisableRecording(
       base::Bind(&DevToolsTracingHandler::BeginReadingRecordingResult,
                  weak_factory_.GetWeakPtr()));
   return command->SuccessResponse(NULL);
 }
 
 void DevToolsTracingHandler::DisableRecording(
     const TracingController::TracingFileResultCallback& callback) {
   is_recording_ = false;
   buffer_usage_poll_timer_.reset();
@@ skipping 24 matching lines @@
   for (std::set<std::string>::const_iterator it = category_set.begin();
        it != category_set.end(); ++it) {
     category_list->AppendString(*it);
   }
 
   response->Set(devtools::Tracing::getCategories::kResponseCategories,
                 category_list);
   SendAsyncResponse(command->SuccessResponse(response));
 }
 
-void DevToolsTracingHandler::OnTracingStarted(
-    scoped_refptr<DevToolsProtocol::Notification> notification) {
+void DevToolsTracingHandler::EnableTracing(const std::string& category_filter) {
   if (is_recording_)
     return;
   is_recording_ = true;
 
   SetupTimer(kDefaultReportingInterval);
 
   TracingController::GetInstance()->EnableRecording(
-      base::debug::CategoryFilter(kDefaultCategories),
+      base::debug::CategoryFilter(category_filter),

[dcheng, 2014/08/27 16:43:31]

I'm not super familiar with inspector. From the CL description, it sounds like
the renderer could already pass arbitrary category_filter strings to the
browser, via 'protocol events' (I am guessing this is what
OnDispatchOnInspectorFrontend is?) Is this true?

       base::debug::TraceOptions(),
       TracingController::EnableRecordingDoneCallback());
+  SendNotification(devtools::Tracing::started::kName, NULL);
 }
 
-void DevToolsTracingHandler::OnTracingStopped(
-    scoped_refptr<DevToolsProtocol::Notification> notification) {
+void DevToolsTracingHandler::DisableTracing() {
   if (!is_recording_)
     return;
   is_recording_ = false;
   DisableRecording(
       base::Bind(&DevToolsTracingHandler::BeginReadingRecordingResult,
                  weak_factory_.GetWeakPtr()));
 }
 
 
 }  // namespace content