Slow Reports: Set a minimum time in between reports, and check for OTR sessions

content/browser/tracing/background_tracing_manager_impl.cc

 // Copyright 2015 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/tracing/background_tracing_manager_impl.h"
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "content/public/browser/background_tracing_preemptive_config.h"
 #include "content/public/browser/background_tracing_reactive_config.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/tracing_delegate.h"
+#include "content/public/common/content_client.h"
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<BackgroundTracingManagerImpl>::Leaky g_controller =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
@@ skipping 45 matching lines @@
 
 BackgroundTracingManager* BackgroundTracingManager::GetInstance() {
   return BackgroundTracingManagerImpl::GetInstance();
 }
 
 BackgroundTracingManagerImpl* BackgroundTracingManagerImpl::GetInstance() {
   return g_controller.Pointer();
 }
 
 BackgroundTracingManagerImpl::BackgroundTracingManagerImpl()
-    : is_gathering_(false),
+    : delegate_(GetContentClient()->browser()->GetTracingDelegate()),
+      is_gathering_(false),
       is_tracing_(false),
       requires_anonymized_data_(true),
       trigger_handle_ids_(0) {
   data_endpoint_wrapper_ = new TraceDataEndpointWrapper(
       base::Bind(&BackgroundTracingManagerImpl::OnFinalizeStarted,
                  base::Unretained(this)));
 }
 
 BackgroundTracingManagerImpl::~BackgroundTracingManagerImpl() {
   NOTREACHED();
@@ skipping 40 matching lines @@
 }
 
 bool BackgroundTracingManagerImpl::SetActiveScenario(
     scoped_ptr<BackgroundTracingConfig> config,
     const BackgroundTracingManager::ReceiveCallback& receive_callback,
     bool requires_anonymized_data) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (is_tracing_)
     return false;
 
+  // TODO(oysteine): Retry when time_until_allowed has elapsed.
+  if (config && delegate_ &&
+      !delegate_->IsAllowedToBeginBackgroundScenario(
+          *config.get(), requires_anonymized_data)) {
+    return false;
+  }
+
   if (!IsSupportedConfig(config.get()))
     return false;
 
   // No point in tracing if there's nowhere to send it.
   if (config && receive_callback.is_null())
     return false;
 
   config_ = config.Pass();
   receive_callback_ = receive_callback;
   requires_anonymized_data_ = requires_anonymized_data;
 
   EnableRecordingIfConfigNeedsIt();
 
   return true;
 }
 
 void BackgroundTracingManagerImpl::EnableRecordingIfConfigNeedsIt() {
   if (!config_)
     return;
 
+  // TODO(oysteine): Retry later.
+  if (delegate_ &&
+      !delegate_->IsAllowedToBeginBackgroundScenario(
+          *config_.get(), requires_anonymized_data_)) {
+    return;
+  }
+
   if (config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE) {
     EnableRecording(GetCategoryFilterStringForCategoryPreset(
         static_cast<BackgroundTracingPreemptiveConfig*>(config_.get())
             ->category_preset),
         base::trace_event::RECORD_CONTINUOUSLY);
   }
   // There is nothing to do in case of reactive tracing.
 }
 
 bool BackgroundTracingManagerImpl::IsAbleToTriggerTracing(
@@ skipping 169 matching lines @@
 
   // Now that a trace has completed, we may need to enable recording again.
   EnableRecordingIfConfigNeedsIt();
 }
 
 void BackgroundTracingManagerImpl::BeginFinalizing(
     StartedFinalizingCallback callback) {
   is_gathering_ = true;
   is_tracing_ = false;
 
-  content::TracingController::GetInstance()->DisableRecording(
-      content::TracingController::CreateCompressedStringSink(
-          data_endpoint_wrapper_));
+  bool is_allowed_finalization =
+      !delegate_ || (config_ &&
+                     delegate_->IsAllowedToEndBackgroundScenario(
+                         *config_.get(), requires_anonymized_data_));
+
+  scoped_refptr<TracingControllerImpl::TraceDataSink> trace_data_sink;
+  if (is_allowed_finalization) {
+    trace_data_sink = content::TracingController::CreateCompressedStringSink(
+        data_endpoint_wrapper_);
+  }
+
+  content::TracingController::GetInstance()->DisableRecording(trace_data_sink);
 
   if (!callback.is_null())
-    callback.Run(true);
+    callback.Run(is_allowed_finalization);
 }
 
 std::string
 BackgroundTracingManagerImpl::GetCategoryFilterStringForCategoryPreset(
     BackgroundTracingConfig::CategoryPreset preset) const {
   switch (preset) {
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK:
       return "benchmark,"
              "disabled-by-default-toplevel.flow,"
              "disabled-by-default-ipc.flow";
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK_DEEP:
       return "*,disabled-by-default-blink.debug.layout";
   }
   NOTREACHED();
   return "";
 }
 
 }  // namspace content