Set up background memory light tracing field trials

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"
@@ skipping 28 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.
+// TODO(ssid): Remove this when background tracing supports trace config strings
+// and memory-infra supports peak detection crbug.com/609935.
+void BenchmarkMemoryLight_TracingEnabledCallback() {
+  base::trace_event::MemoryDumpManager::GetInstance()->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 144 matching lines @@
           *config_.get(), requires_anonymized_data_)) {
     AbortScenario();
   }
 }
 
 void BackgroundTracingManagerImpl::StartTracingIfConfigNeedsIt() {
   if (!config_)
     return;
 
   if (config_->tracing_mode() == BackgroundTracingConfigImpl::PREEMPTIVE) {
-    StartTracing(
-        GetCategoryFilterStringForCategoryPreset(config_->category_preset()),
-        base::trace_event::RECORD_CONTINUOUSLY);
+    StartTracing(config_->category_preset(),
+                 base::trace_event::RECORD_CONTINUOUSLY);
   }
   // There is nothing to do in case of reactive tracing.
 }
 
 BackgroundTracingRule*
 BackgroundTracingManagerImpl::GetRuleAbleToTriggerTracing(
     TriggerHandle handle) const {
   if (!config_)
     return nullptr;
 
@@ skipping 80 matching lines @@
 
   int trace_delay = triggered_rule->GetTraceDelay();
 
   if (config_->tracing_mode() == BackgroundTracingConfigImpl::REACTIVE) {
     // In reactive mode, a trigger starts tracing, or finalizes tracing
     // immediately if it's already running.
     RecordBackgroundTracingMetric(REACTIVE_TRIGGERED);
 
     if (!is_tracing_) {
       // It was not already tracing, start a new trace.
-      StartTracing(GetCategoryFilterStringForCategoryPreset(
-                       triggered_rule->category_preset()),
+      StartTracing(triggered_rule->category_preset(),
                    base::trace_event::RECORD_UNTIL_FULL);
     } else {
       // Reactive configs that trigger again while tracing should just
       // end right away (to not capture multiple navigations, for example).
       trace_delay = -1;
     }
   } else {
     // In preemptive mode, a trigger starts finalizing a trace if one is
     // running and we're not got a finalization timer running,
     // otherwise we do nothing.
@@ skipping 53 matching lines @@
     const base::Closure& callback) {
   rule_triggered_callback_for_testing_ = callback;
 };
 
 void BackgroundTracingManagerImpl::FireTimerForTesting() {
   DCHECK(tracing_timer_);
   tracing_timer_->FireTimerForTesting();
 }
 
 void BackgroundTracingManagerImpl::StartTracing(
-    std::string category_filter_str,
+    BackgroundTracingConfigImpl::CategoryPreset preset,
     base::trace_event::TraceRecordMode record_mode) {
-  base::trace_event::TraceConfig trace_config(category_filter_str, 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.
+    trace_config.ResetMemoryDumpConfig(
+        base::trace_event::TraceConfig::MemoryDumpConfig());
+    tracing_enabled_callback =
+        base::Bind(&BenchmarkMemoryLight_TracingEnabledCallback);
+  }
+
   is_tracing_ = TracingController::GetInstance()->StartTracing(
-      trace_config, tracing_enabled_callback_for_testing_);
+      trace_config, tracing_enabled_callback);
   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 103 matching lines @@
       return "benchmark,toplevel,gpu";
     case BackgroundTracingConfigImpl::CategoryPreset::BENCHMARK_IPC:
       return "benchmark,toplevel,ipc";
     case BackgroundTracingConfigImpl::CategoryPreset::BENCHMARK_STARTUP:
       return "benchmark,toplevel,startup,disabled-by-default-file,"
              "disabled-by-default-toplevel.flow,"
              "disabled-by-default-ipc.flow";
     case BackgroundTracingConfigImpl::CategoryPreset::BENCHMARK_BLINK_GC:
       return "blink_gc,disabled-by-default-blink_gc";
     case BackgroundTracingConfigImpl::CategoryPreset::BENCHMARK_MEMORY_HEAVY:
+    case BackgroundTracingConfigImpl::CategoryPreset::BENCHMARK_MEMORY_LIGHT:
       return "-*,disabled-by-default-memory-infra";
     case BackgroundTracingConfigImpl::CategoryPreset::
         BENCHMARK_EXECUTION_METRIC:
       return "blink.console,v8";
     case BackgroundTracingConfigImpl::CategoryPreset::BLINK_STYLE:
       return "blink_style";
     case BackgroundTracingConfigImpl::CategoryPreset::CATEGORY_PRESET_UNSET:
       NOTREACHED();
   }
   NOTREACHED();
   return "";
 }
 
 }  // namspace content