Make tracing based Timeline stop after reloading inspected page

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 30 matching lines @@
   base::DeleteFile(path, false);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(callback, make_scoped_refptr(
           base::RefCountedString::TakeString(&trace_data))));
 }
 
 }  // namespace
 
 DevToolsTracingHandler::DevToolsTracingHandler(
     DevToolsTracingHandler::Target target)
-    : weak_factory_(this), target_(target) {
+    : 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)));
 }
@@ skipping 69 matching lines @@
     } else if (*iter == kEnableSampling) {
       ret |= TracingController::ENABLE_SAMPLING;
     }
   }
   return static_cast<TracingController::Options>(ret);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 DevToolsTracingHandler::OnStart(
     scoped_refptr<DevToolsProtocol::Command> command) {
+  is_recording_ = true;
   std::string categories;
   base::DictionaryValue* params = command->params();
   if (params)
     params->GetString(devtools::Tracing::start::kParamCategories, &categories);
 
   TracingController::Options options = TracingController::DEFAULT_OPTIONS;
   if (params && params->HasKey(devtools::Tracing::start::kParamOptions)) {
     std::string options_param;
     params->GetString(devtools::Tracing::start::kParamOptions, &options_param);
     options = TraceOptionsFromString(options_param);
@@ skipping 53 matching lines @@
 DevToolsTracingHandler::OnEnd(
     scoped_refptr<DevToolsProtocol::Command> command) {
   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();
   TracingController::GetInstance()->DisableRecording(base::FilePath(),
                                                      callback);
 }
 
 void DevToolsTracingHandler::OnClientDetached() {
+  if (is_recording_)
     DisableRecording();
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 DevToolsTracingHandler::OnGetCategories(
     scoped_refptr<DevToolsProtocol::Command> command) {
   TracingController::GetInstance()->GetCategories(
       base::Bind(&DevToolsTracingHandler::OnCategoriesReceived,
                  weak_factory_.GetWeakPtr(),
                  command));
   return command->AsyncResponsePromise();
 }
 
 void DevToolsTracingHandler::OnCategoriesReceived(
     scoped_refptr<DevToolsProtocol::Command> command,
     const std::set<std::string>& category_set) {
   base::DictionaryValue* response = new base::DictionaryValue;
   base::ListValue* category_list = new base::ListValue;
   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));
 }
 
 }  // namespace content