Add EnabledStateObserver to BackgroundTracingManager

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 <utility>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "content/browser/tracing/background_memory_tracing_observer.h"
 #include "content/browser/tracing/background_tracing_rule.h"
 #include "content/browser/tracing/tracing_controller_impl.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"
 #include "content/public/common/content_switches.h"
 
 namespace content {
 
@@ skipping 15 matching lines @@
   FINALIZATION_COMPLETE = 8,
   SCENARIO_ACTION_FAILED_LOWRES_CLOCK = 9,
   NUMBER_OF_BACKGROUND_TRACING_METRICS,
 };
 
 void RecordBackgroundTracingMetric(BackgroundTracingMetrics metric) {
   UMA_HISTOGRAM_ENUMERATION("Tracing.Background.ScenarioState", metric,
                             NUMBER_OF_BACKGROUND_TRACING_METRICS);
 }
 
-// Tracing enabled callback for BENCHMARK_MEMORY_LIGHT category preset.
-void BenchmarkMemoryLight_TracingEnabledCallback() {
-  auto* dump_manager = base::trace_event::MemoryDumpManager::GetInstance();
-  dump_manager->RequestGlobalDump(
-      base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
-      base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND);
-}
-
 }  // namespace
 
 BackgroundTracingManagerImpl::TracingTimer::TracingTimer(
     StartedFinalizingCallback callback) : callback_(callback) {
 }
 
 BackgroundTracingManagerImpl::TracingTimer::~TracingTimer() {
 }
 
 void BackgroundTracingManagerImpl::TracingTimer::StartTimer(int seconds) {
@@ skipping 22 matching lines @@
 BackgroundTracingManagerImpl* BackgroundTracingManagerImpl::GetInstance() {
   return g_controller.Pointer();
 }
 
 BackgroundTracingManagerImpl::BackgroundTracingManagerImpl()
     : delegate_(GetContentClient()->browser()->GetTracingDelegate()),
       is_gathering_(false),
       is_tracing_(false),
       requires_anonymized_data_(true),
       trigger_handle_ids_(0),
-      triggered_named_event_handle_(-1) {}
+      triggered_named_event_handle_(-1) {
+  AddEnabledStateObserver(BackgroundMemoryTracingObserver::GetInstance());
+}
 
 BackgroundTracingManagerImpl::~BackgroundTracingManagerImpl() {
   NOTREACHED();
 }
 
 void BackgroundTracingManagerImpl::WhenIdle(
     base::Callback<void()> idle_callback) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   idle_callback_ = idle_callback;
 }
@@ skipping 74 matching lines @@
     }
 
     if (!config_->disable_blink_features().empty()) {
       command_line->AppendSwitchASCII(switches::kDisableBlinkFeatures,
                                       config_->disable_blink_features());
     }
   }
 
   StartTracingIfConfigNeedsIt();
 
+  for (auto* observer : background_tracing_observer_list_)
+    observer->OnScenarioActivated(*config_);
   RecordBackgroundTracingMetric(SCENARIO_ACTIVATED_SUCCESSFULLY);
   return true;
 }
 
 bool BackgroundTracingManagerImpl::HasActiveScenario() {
   return !!config_;
 }
 
+void BackgroundTracingManagerImpl::OnStartTracingDone(
+    BackgroundTracingConfigImpl::CategoryPreset preset) {
+  DCHECK(BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  for (auto* observer : background_tracing_observer_list_)
+    observer->OnTracingEnabled(preset);
+}
+
+void BackgroundTracingManagerImpl::AddEnabledStateObserver(
+    EnabledStateObserver* observer) {
+  DCHECK(BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  background_tracing_observer_list_.push_back(observer);
+}
+
+void BackgroundTracingManagerImpl::RemoveEnabledStateObserver(
+    EnabledStateObserver* observer) {
+  DCHECK(BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  std::vector<EnabledStateObserver*>::iterator it =
+      std::find(background_tracing_observer_list_.begin(),
+                background_tracing_observer_list_.end(), observer);
+  if (it != background_tracing_observer_list_.end())
+    background_tracing_observer_list_.erase(it);
+}
+
 bool BackgroundTracingManagerImpl::IsTracingForTesting() {
   return is_tracing_;
 }
 
 void BackgroundTracingManagerImpl::ValidateStartupScenario() {
   if (!config_ || !delegate_)
     return;
 
   if (!delegate_->IsAllowedToBeginBackgroundScenario(
           *config_.get(), requires_anonymized_data_)) {
@@ skipping 167 matching lines @@
 std::string BackgroundTracingManagerImpl::GetTriggerNameFromHandle(
     BackgroundTracingManager::TriggerHandle handle) const {
   CHECK(IsTriggerHandleValid(handle));
   return trigger_handles_.find(handle)->second;
 }
 
 void BackgroundTracingManagerImpl::InvalidateTriggerHandlesForTesting() {
   trigger_handles_.clear();
 }
 
-void BackgroundTracingManagerImpl::SetTracingEnabledCallbackForTesting(
-    const base::Closure& callback) {
-  tracing_enabled_callback_for_testing_ = callback;
-};
-
 void BackgroundTracingManagerImpl::SetRuleTriggeredCallbackForTesting(
     const base::Closure& callback) {
   rule_triggered_callback_for_testing_ = callback;
 };
 
 void BackgroundTracingManagerImpl::FireTimerForTesting() {
   DCHECK(tracing_timer_);
   tracing_timer_->FireTimerForTesting();
 }
 
 void BackgroundTracingManagerImpl::StartTracing(
     BackgroundTracingConfigImpl::CategoryPreset preset,
     base::trace_event::TraceRecordMode record_mode) {
   base::trace_event::TraceConfig trace_config(
       GetCategoryFilterStringForCategoryPreset(preset), record_mode);
   if (requires_anonymized_data_)
     trace_config.EnableArgumentFilter();
 
-  base::Closure tracing_enabled_callback;
-  if (!tracing_enabled_callback_for_testing_.is_null()) {
-    tracing_enabled_callback = tracing_enabled_callback_for_testing_;
-  } else if (preset == BackgroundTracingConfigImpl::CategoryPreset::
-                           BENCHMARK_MEMORY_LIGHT) {
-    // On memory light mode, the periodic memory dumps are disabled and a single
-    // memory dump is requested after tracing is enabled in all the processes.
-    // TODO(ssid): Remove this when background tracing supports trace config
-    // strings and memory-infra supports peak detection crbug.com/609935.
+  if (preset ==
+      BackgroundTracingConfigImpl::CategoryPreset::BENCHMARK_MEMORY_LIGHT) {
+    // On memory light mode, the periodic memory dumps are disabled.
+    // TODO(ssid): Remove this when memory-infra supports peak detection
+    // crbug.com/609935.
     base::trace_event::TraceConfig::MemoryDumpConfig memory_config;
     memory_config.allowed_dump_modes =
         std::set<base::trace_event::MemoryDumpLevelOfDetail>(
             {base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND});
     trace_config.ResetMemoryDumpConfig(memory_config);
-    tracing_enabled_callback =
-        base::Bind(&BenchmarkMemoryLight_TracingEnabledCallback);
   }
 
   is_tracing_ = TracingController::GetInstance()->StartTracing(
-      trace_config, tracing_enabled_callback);
+      trace_config,
+      base::Bind(&BackgroundTracingManagerImpl::OnStartTracingDone,
+                 base::Unretained(this), preset));
   RecordBackgroundTracingMetric(RECORDING_ENABLED);
 }
 
 void BackgroundTracingManagerImpl::OnFinalizeStarted(
     std::unique_ptr<const base::DictionaryValue> metadata,
     base::RefCountedString* file_contents) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   RecordBackgroundTracingMetric(FINALIZATION_STARTED);
   UMA_HISTOGRAM_MEMORY_KB("Tracing.Background.FinalizingTraceSizeInKB",
@@ skipping 120 matching lines @@
     case BackgroundTracingConfigImpl::CategoryPreset::BLINK_STYLE:
       return "blink_style";
     case BackgroundTracingConfigImpl::CategoryPreset::CATEGORY_PRESET_UNSET:
       NOTREACHED();
   }
   NOTREACHED();
   return "";
 }
 
 }  // namspace content