Slow Reports - Add message filter to trigger background traces from child processes.

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/json/json_writer.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/time/time.h"
+#include "components/tracing/tracing_messages.h"
+#include "content/browser/tracing/trace_message_filter.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 {
@@ skipping 53 matching lines @@
 
 BackgroundTracingManager* BackgroundTracingManager::GetInstance() {
   return BackgroundTracingManagerImpl::GetInstance();
 }
 
 BackgroundTracingManagerImpl* BackgroundTracingManagerImpl::GetInstance() {
   return g_controller.Pointer();
 }
 
 BackgroundTracingManagerImpl::BackgroundTracingManagerImpl()
-    : delegate_(GetContentClient()->browser()->GetTracingDelegate()),
-      is_gathering_(false),
+    : is_gathering_(false),
       is_tracing_(false),
       requires_anonymized_data_(true),
       trigger_handle_ids_(0) {
+  CreateDelegate();
 }
 
 BackgroundTracingManagerImpl::~BackgroundTracingManagerImpl() {
   NOTREACHED();
 }
 
+void BackgroundTracingManagerImpl::CreateDelegate() {
+  // The delegate must be instantiated on the UI thread, so if the
+  // first access to the BackgroundTracingManagerImpl is from another thread

[oystein (OOO til 10th of July), 2015/07/21 20:52:45]

When does this happen? Can we be sure there's no race conditions here, if the
BackgroundTracingManagerImpl can be lazily instantiated on multiple threads?

[shatch, 2015/07/22 17:44:13]

This happened in a few tests where the message filter called in to add a filter,
but I think this is unnecessary now if we're piggybacking on the trace message
filter, which does some checks before adding the filter.

LazyInstance guarantees thread safety for creation.

+  // we'll need to defer initializing it.
+  if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&BackgroundTracingManagerImpl::CreateDelegate,
+                   base::Unretained(this)));
+    return;
+  }
+  delegate_.reset(GetContentClient()->browser()->GetTracingDelegate());
+}
+
 void BackgroundTracingManagerImpl::WhenIdle(
     base::Callback<void()> idle_callback) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   idle_callback_ = idle_callback;
 }
 
 bool BackgroundTracingManagerImpl::IsSupportedConfig(
     BackgroundTracingConfig* config) {
   // No config is just fine, we just don't do anything.
   if (!config)
@@ skipping 47 matching lines @@
             MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE) {
       continue;
     }
 
     if (mode == CLEAR_CALLBACKS) {
       base::StatisticsRecorder::ClearCallback(
           configs[i].histogram_trigger_info.histogram_name);
     } else {
       base::StatisticsRecorder::SetCallback(
           configs[i].histogram_trigger_info.histogram_name,
-          base::Bind(&BackgroundTracingManagerImpl::OnHistogramChanged,
+          base::Bind(&BackgroundTracingManagerImpl::OnHistogramChangedCallback,
                      base::Unretained(this),
                      configs[i].histogram_trigger_info.histogram_name,
                      configs[i].histogram_trigger_info.histogram_value));
     }
   }
+
+  SetupFiltersFromConfig(mode);
 }
 
-void BackgroundTracingManagerImpl::OnHistogramChanged(
-    const std::string& histogram_name,
-    base::Histogram::Sample reference_value,
-    base::Histogram::Sample actual_value) {
+void BackgroundTracingManagerImpl::OnHistogramTrigger(
+    const std::string& histogram_name) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&BackgroundTracingManagerImpl::OnHistogramChanged,
-                   base::Unretained(this), histogram_name, reference_value,
-                   actual_value));
+        base::Bind(&BackgroundTracingManagerImpl::OnHistogramTrigger,
+                   base::Unretained(this), histogram_name));
     return;
   }
 
   CHECK(config_ &&
         config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE);
 
+  if (!is_tracing_ || is_gathering_)
+    return;
+
+  BackgroundTracingPreemptiveConfig* preemptive_config =
+      static_cast<BackgroundTracingPreemptiveConfig*>(config_.get());
+  const std::vector<BackgroundTracingPreemptiveConfig::MonitoringRule>&
+      configs = preemptive_config->configs;
+  for (size_t i = 0; i < configs.size(); ++i) {
+    if (configs[i].type !=
+        BackgroundTracingPreemptiveConfig::
+            MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE) {
+      continue;
+    }
+
+    if (configs[i].histogram_trigger_info.histogram_name == histogram_name) {
+      RecordBackgroundTracingMetric(PREEMPTIVE_TRIGGERED);
+      BeginFinalizing(StartedFinalizingCallback());
+    }
+  }
+}
+
+void BackgroundTracingManagerImpl::OnHistogramChangedCallback(
+    const std::string& histogram_name,
+    base::Histogram::Sample reference_value,
+    base::Histogram::Sample actual_value) {
   if (reference_value > actual_value)
     return;
 
-  if (!is_tracing_ || is_gathering_)
-    return;
-
-  RecordBackgroundTracingMetric(PREEMPTIVE_TRIGGERED);
-  BeginFinalizing(StartedFinalizingCallback());
+  OnHistogramTrigger(histogram_name);
 }
 
 bool BackgroundTracingManagerImpl::SetActiveScenario(
     scoped_ptr<BackgroundTracingConfig> config,
     const BackgroundTracingManager::ReceiveCallback& receive_callback,
     DataFiltering data_filtering) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   RecordBackgroundTracingMetric(SCENARIO_ACTIVATION_REQUESTED);
 
   if (is_tracing_)
@@ skipping 36 matching lines @@
   EnableRecordingIfConfigNeedsIt();
 
   RecordBackgroundTracingMetric(SCENARIO_ACTIVATED_SUCCESSFULLY);
   return true;
 }
 
 bool BackgroundTracingManagerImpl::HasActiveScenarioForTesting() {
   return config_;
 }
 
+void BackgroundTracingManagerImpl::AddFilter(
+    scoped_refptr<TraceMessageFilter> filter) {
+  if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {

[oystein (OOO til 10th of July), 2015/07/21 20:52:45]

Which threads can this be called on? Wouldn't this be consistent?

[shatch, 2015/07/22 17:44:13]

Called via OnChildSupportsTracing from the TraceMessageFtiler on the IO thread.
Moot if we reuse the filters from TracingControllerImpl.

+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&BackgroundTracingManagerImpl::AddFilter,
+                   base::Unretained(this), filter));
+    return;
+  }
+
+  filters_.insert(filter);
+  SetupFilterFromConfig(filter, BIND_CALLBACKS);
+}
+
+void BackgroundTracingManagerImpl::RemoveFilter(
+    scoped_refptr<TraceMessageFilter> filter) {
+  if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {

[oystein (OOO til 10th of July), 2015/07/21 20:52:45]

Same thread question as AddFilter

+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&BackgroundTracingManagerImpl::RemoveFilter,
+                   base::Unretained(this), filter));
+    return;
+  }
+
+  filters_.erase(filter);
+}
+
+void BackgroundTracingManagerImpl::SetupFiltersFromConfig(
+    BackgroundTracingManagerImpl::SetupUMACallMode mode) {
+  for (auto it = filters_.begin(); it != filters_.end(); ++it)
+    SetupFilterFromConfig(*it, mode);
+}
+
+void BackgroundTracingManagerImpl::SetupFilterFromConfig(
+    scoped_refptr<TraceMessageFilter> filter,
+    BackgroundTracingManagerImpl::SetupUMACallMode mode) {
+  if (!config_ ||
+      config_->mode != BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE)
+    return;
+
+  BackgroundTracingPreemptiveConfig* preemptive_config =
+      static_cast<BackgroundTracingPreemptiveConfig*>(config_.get());
+
+  const std::vector<BackgroundTracingPreemptiveConfig::MonitoringRule>&
+      configs = preemptive_config->configs;
+
+  for (size_t i = 0; i < configs.size(); ++i) {
+    if (configs[i].type !=
+        BackgroundTracingPreemptiveConfig::
+            MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE) {
+      continue;
+    }
+
+    if (mode == CLEAR_CALLBACKS) {
+      filter->Send(new TracingMsg_ClearUMACallback(
+          configs[i].histogram_trigger_info.histogram_name));
+    } else {
+      filter->Send(new TracingMsg_SetUMACallback(
+          configs[i].histogram_trigger_info.histogram_name,
+          configs[i].histogram_trigger_info.histogram_value));
+    }
+  }
+}
+
 void BackgroundTracingManagerImpl::ValidateStartupScenario() {
   if (!config_ || !delegate_)
     return;
 
   if (!delegate_->IsAllowedToBeginBackgroundScenario(
           *config_.get(), requires_anonymized_data_)) {
     AbortScenario();
   }
 }
 
@@ skipping 250 matching lines @@
     RecordBackgroundTracingMetric(FINALIZATION_DISALLOWED);
   }
 
   content::TracingController::GetInstance()->DisableRecording(trace_data_sink);
 
   if (!callback.is_null())
     callback.Run(is_allowed_finalization);
 }
 
 void BackgroundTracingManagerImpl::AbortScenario() {
+  SetupUMACallbacks(CLEAR_CALLBACKS);
+
   is_tracing_ = false;
   config_.reset();
 
   content::TracingController::GetInstance()->DisableRecording(nullptr);
 }
 
 std::string
 BackgroundTracingManagerImpl::GetCategoryFilterStringForCategoryPreset(
     BackgroundTracingConfig::CategoryPreset preset) const {
   switch (preset) {
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK:
       return "benchmark,toplevel";
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK_DEEP:
       return "*,disabled-by-default-benchmark.detailed";
   }
   NOTREACHED();
   return "";
 }
 
 }  // namspace content