Background tracing: Use the new Perfetto Consumer mojo endpoint

rather than the TracingController.

This is in preparation for being able to handle proto traces
in addition to JSON.

R=ssid@chromium.org
BUG=925151

Change-Id: I91ed3c9648587fb19a5102b869a5d5ab688e0187
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1546146
Commit-Queue: oysteine <oysteine@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: ssid <ssid@chromium.org>
Cr-Commit-Position: refs/heads/master@{#657413}

chrome/browser/tracing/background_tracing_field_trial_unittest.cc

@@ -21,7 +21,7 @@ class BackgroundTracingTest : public testing::Test {
   BackgroundTracingTest() = default;
 
   void TearDown() override {
-    content::BackgroundTracingManager::GetInstance()->AbortScenario();
+    content::BackgroundTracingManager::GetInstance()->AbortScenarioForTesting();
   }
 
  private:

chrome/browser/tracing/background_tracing_metrics_provider_unittest.cc

@@ -34,7 +34,7 @@ TEST_F(BackgroundTracingMetricsProviderTest, UploadsTraceLog) {
   EXPECT_FALSE(provider.HasIndependentMetrics());
 
   content::BackgroundTracingManager::GetInstance()->SetTraceToUploadForTesting(
-      kDummyTrace);
+      std::make_unique<std::string>(kDummyTrace));
 
   EXPECT_TRUE(provider.HasIndependentMetrics());
   metrics::ChromeUserMetricsExtension uma_proto;
@@ -57,11 +57,11 @@ TEST_F(BackgroundTracingMetricsProviderTest, HandleMissingTrace) {
   EXPECT_FALSE(provider.HasIndependentMetrics());
 
   content::BackgroundTracingManager::GetInstance()->SetTraceToUploadForTesting(
-      kDummyTrace);
+      std::make_unique<std::string>(kDummyTrace));
   EXPECT_TRUE(provider.HasIndependentMetrics());
 
   content::BackgroundTracingManager::GetInstance()->SetTraceToUploadForTesting(
-      "");
+      nullptr);
   metrics::ChromeUserMetricsExtension uma_proto;
   uma_proto.set_client_id(100);
   uma_proto.set_session_id(15);

chrome/browser/tracing/chrome_tracing_delegate_browsertest.cc

@@ -148,7 +148,7 @@ IN_PROC_BROWSER_TEST_F(ChromeTracingDelegateBrowserTest,
       local_state->GetInt64(prefs::kBackgroundTracingLastUpload));
   EXPECT_FALSE(last_upload_time.is_null());
 
-  content::BackgroundTracingManager::GetInstance()->AbortScenario();
+  content::BackgroundTracingManager::GetInstance()->AbortScenarioForTesting();
   base::RunLoop wait_for_abort;
   content::BackgroundTracingManager::GetInstance()->WhenIdle(
       wait_for_abort.QuitClosure());
@@ -188,7 +188,7 @@ IN_PROC_BROWSER_TEST_F(ChromeTracingDelegateBrowserTest,
       local_state->GetInt64(prefs::kBackgroundTracingLastUpload));
   EXPECT_FALSE(last_upload_time.is_null());
 
-  content::BackgroundTracingManager::GetInstance()->AbortScenario();
+  content::BackgroundTracingManager::GetInstance()->AbortScenarioForTesting();
   base::RunLoop wait_for_abort;
   content::BackgroundTracingManager::GetInstance()->WhenIdle(
       wait_for_abort.QuitClosure());

content/browser/tracing/background_tracing_active_scenario.h

@@ -11,7 +11,9 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/tracing/background_tracing_config_impl.h"
+#include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/browser/background_tracing_manager.h"
+#include "services/tracing/public/mojom/perfetto_service.mojom.h"
 
 namespace base {
 class RefCountedString;
@@ -24,13 +26,14 @@ class BackgroundTracingConfigImpl;
 class BackgroundTracingActiveScenario {
  public:
   enum class State { kIdle, kTracing, kFinalizing, kUploading, kAborted };
+  class TracingSession;
 
   BackgroundTracingActiveScenario(
       std::unique_ptr<const BackgroundTracingConfigImpl> config,
       bool requires_anonymized_data,
       BackgroundTracingManager::ReceiveCallback receive_callback,
       base::OnceClosure on_aborted_callback);
-  ~BackgroundTracingActiveScenario();
+  virtual ~BackgroundTracingActiveScenario();
 
   void StartTracingIfConfigNeedsIt();
   void AbortScenario();
@@ -39,6 +42,7 @@ class BackgroundTracingActiveScenario {
   void GenerateMetadataDict(base::DictionaryValue* metadata_dict);
   State state() const { return scenario_state_; }
   bool requires_anonymized_data() const { return requires_anonymized_data_; }
+  base::WeakPtr<BackgroundTracingActiveScenario> GetWeakPtr();
 
   void TriggerNamedEvent(
       BackgroundTracingManager::TriggerHandle handle,
@@ -48,6 +52,16 @@ class BackgroundTracingActiveScenario {
       const BackgroundTracingRule* triggered_rule,
       BackgroundTracingManager::StartedFinalizingCallback callback);
 
+  // Called by LegacyTracingSession when the final trace data is ready.
+  void OnJSONDataComplete(std::unique_ptr<const base::DictionaryValue> metadata,
+                          base::RefCountedString*);
+  // Called by the PerfettoTracingSession when the proto trace is ready.
+  void OnProtoDataComplete(std::unique_ptr<std::string> proto_trace);
+
+  // Called when the finalized trace data has been uploaded/transferred away
+  // from the background tracing system.
+  void OnFinalizeComplete(bool success);
+
   // For testing
   CONTENT_EXPORT void FireTimerForTesting();
   CONTENT_EXPORT void SetRuleTriggeredCallbackForTesting(
@@ -56,20 +70,15 @@ class BackgroundTracingActiveScenario {
  private:
   void StartTracing(BackgroundTracingConfigImpl::CategoryPreset,
                     base::trace_event::TraceRecordMode);
-
   void BeginFinalizing(
       BackgroundTracingManager::StartedFinalizingCallback callback);
-  void OnTracingStopped(base::RepeatingClosure started_finalizing_closure,
-                        std::unique_ptr<const base::DictionaryValue> metadata,
-                        base::RefCountedString*);
-
-  void OnFinalizeComplete(bool success);
 
   BackgroundTracingRule* GetRuleAbleToTriggerTracing(
       const std::string& trigger_name);
 
   void SetState(State new_state);
 
+  std::unique_ptr<TracingSession> tracing_session_;
   std::unique_ptr<const BackgroundTracingConfigImpl> config_;
   bool requires_anonymized_data_;
   State scenario_state_;
@@ -78,6 +87,7 @@ class BackgroundTracingActiveScenario {
   BackgroundTracingManager::ReceiveCallback receive_callback_;
   BackgroundTracingManager::TriggerHandle triggered_named_event_handle_;
   base::OnceClosure on_aborted_callback_;
+  base::OnceClosure started_finalizing_closure_;
 
   class TracingTimer;
   std::unique_ptr<TracingTimer> tracing_timer_;

content/browser/tracing/background_tracing_manager_impl.cc

@@ -162,18 +162,19 @@ bool BackgroundTracingManagerImpl::HasActiveScenario() {
 }
 
 bool BackgroundTracingManagerImpl::HasTraceToUpload() {
-  // TODO(oysteine): This should return the collected trace once we have the new
-  // coordinator API to collect protos. https://crbug.com/925142.
-  // Note: This can be called on any thread and needs to be thread safe.
-  return !trace_to_upload_for_testing_.empty();
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return !trace_to_upload_.empty();
 }
 
 std::string BackgroundTracingManagerImpl::GetLatestTraceToUpload() {
-  // TODO(oysteine): This should return the collected trace once we have the new
-  // coordinator API to collect protos. https://crbug.com/925142.
-  // Note: This can be called on any thread and needs to be thread safe.
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::string ret;
-  ret.swap(trace_to_upload_for_testing_);
+  ret.swap(trace_to_upload_);
+
+  if (active_scenario_) {
+    active_scenario_->OnFinalizeComplete(true);
+  }
+
   return ret;
 }
 
@@ -241,8 +242,18 @@ bool BackgroundTracingManagerImpl::IsTracingForTesting() {
 }
 
 void BackgroundTracingManagerImpl::SetTraceToUploadForTesting(
-    base::StringPiece data) {
-  trace_to_upload_for_testing_ = data.data();
+    std::unique_ptr<std::string> trace_data) {
+  SetTraceToUpload(std::move(trace_data));
+}
+
+void BackgroundTracingManagerImpl::SetTraceToUpload(
+    std::unique_ptr<std::string> trace_data) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (trace_data) {
+    trace_to_upload_.swap(*trace_data);
+  } else {
+    trace_to_upload_.clear();
+  }
 }
 
 void BackgroundTracingManagerImpl::ValidateStartupScenario() {
@@ -315,7 +326,6 @@ BackgroundTracingManagerImpl::RegisterTriggerType(const char* trigger_name) {
 
   return static_cast<TriggerHandle>(trigger_handle_ids_);
 }
-
 bool BackgroundTracingManagerImpl::IsTriggerHandleValid(
     BackgroundTracingManager::TriggerHandle handle) const {
   return trigger_handles_.find(handle) != trigger_handles_.end();
@@ -368,6 +378,10 @@ BackgroundTracingManagerImpl::GenerateMetadataDict() {
   return metadata_dict;
 }
 
+void BackgroundTracingManagerImpl::AbortScenarioForTesting() {
+  AbortScenario();
+}
+
 void BackgroundTracingManagerImpl::AbortScenario() {
   if (active_scenario_) {
     active_scenario_->AbortScenario();

content/browser/tracing/background_tracing_manager_impl.h

@@ -78,7 +78,7 @@ class BackgroundTracingManagerImpl : public BackgroundTracingManager {
   bool SetActiveScenario(std::unique_ptr<BackgroundTracingConfig>,
                          ReceiveCallback,
                          DataFiltering data_filtering) override;
-  CONTENT_EXPORT void AbortScenario() override;
+  void AbortScenario();
   bool HasActiveScenario() override;
 
   // Named triggers
@@ -92,6 +92,7 @@ class BackgroundTracingManagerImpl : public BackgroundTracingManager {
                        StartedFinalizingCallback callback);
   bool HasTraceToUpload() override;
   std::string GetLatestTraceToUpload() override;
+  void SetTraceToUpload(std::unique_ptr<std::string> trace_data);
 
   // Add/remove EnabledStateObserver.
   CONTENT_EXPORT void AddEnabledStateObserver(EnabledStateObserver* observer);
@@ -116,9 +117,9 @@ class BackgroundTracingManagerImpl : public BackgroundTracingManager {
   CONTENT_EXPORT void InvalidateTriggerHandlesForTesting();
   CONTENT_EXPORT bool IsTracingForTesting();
   void WhenIdle(IdleCallback idle_callback) override;
-
+  CONTENT_EXPORT void AbortScenarioForTesting() override;
   CONTENT_EXPORT void SetTraceToUploadForTesting(
-      base::StringPiece data) override;
+      std::unique_ptr<std::string> trace_data) override;
 
  private:
   friend class base::NoDestructor<BackgroundTracingManagerImpl>;
@@ -147,8 +148,9 @@ class BackgroundTracingManagerImpl : public BackgroundTracingManager {
 
   IdleCallback idle_callback_;
   base::RepeatingClosure tracing_enabled_callback_for_testing_;
+
   // This field contains serialized trace log proto.
-  std::string trace_to_upload_for_testing_;
+  std::string trace_to_upload_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundTracingManagerImpl);
 };

content/public/browser/background_tracing_manager.h

@@ -102,8 +102,9 @@ class BackgroundTracingManager {
   virtual std::string GetLatestTraceToUpload() = 0;
 
   // For tests
-  virtual void AbortScenario() = 0;
-  virtual void SetTraceToUploadForTesting(base::StringPiece data) = 0;
+  virtual void AbortScenarioForTesting() = 0;
+  virtual void SetTraceToUploadForTesting(
+      std::unique_ptr<std::string> trace_data) = 0;
 
  protected:
   virtual ~BackgroundTracingManager() {}

services/tracing/public/cpp/perfetto/perfetto_config.cc

@@ -15,7 +15,8 @@
 namespace tracing {
 
 perfetto::TraceConfig GetDefaultPerfettoConfig(
-    const base::trace_event::TraceConfig& chrome_config) {
+    const base::trace_event::TraceConfig& chrome_config,
+    bool privacy_filtering_enabled) {
   perfetto::TraceConfig perfetto_config;
 
   size_t size_limit = chrome_config.GetTraceBufferSizeInKb();
@@ -52,6 +53,7 @@ perfetto::TraceConfig GetDefaultPerfettoConfig(
   trace_event_config->set_target_buffer(0);
   auto* chrome_proto_config = trace_event_config->mutable_chrome_config();
   chrome_proto_config->set_trace_config(chrome_config_string);
+  chrome_proto_config->set_privacy_filtering_enabled(privacy_filtering_enabled);
 
 // Capture system trace events if supported and enabled. The datasources will
 // only emit events if system tracing is enabled in |chrome_config|.
@@ -62,6 +64,8 @@ perfetto::TraceConfig GetDefaultPerfettoConfig(
   system_trace_config->set_target_buffer(0);
   auto* system_chrome_config = system_trace_config->mutable_chrome_config();
   system_chrome_config->set_trace_config(chrome_config_string);
+  system_chrome_config->set_privacy_filtering_enabled(
+      privacy_filtering_enabled);
 #endif
 
 #if defined(OS_CHROMEOS)
@@ -70,6 +74,7 @@ perfetto::TraceConfig GetDefaultPerfettoConfig(
   arc_trace_config->set_target_buffer(0);
   auto* arc_chrome_config = arc_trace_config->mutable_chrome_config();
   arc_chrome_config->set_trace_config(chrome_config_string);
+  arc_chrome_config->set_privacy_filtering_enabled(privacy_filtering_enabled);
 #endif
 
   // Also capture global metadata.
@@ -79,7 +84,8 @@ perfetto::TraceConfig GetDefaultPerfettoConfig(
   trace_metadata_config->set_target_buffer(0);
   auto* metadata_chrome_config = trace_metadata_config->mutable_chrome_config();
   metadata_chrome_config->set_trace_config(chrome_config_string);
-  // TODO(ssid): Also set privacy_filtering_enabled here.
+  metadata_chrome_config->set_privacy_filtering_enabled(
+      privacy_filtering_enabled);
 
   return perfetto_config;
 }

services/tracing/public/cpp/perfetto/perfetto_config.h

@@ -17,7 +17,8 @@ class TraceConfig;
 namespace tracing {
 
 perfetto::TraceConfig COMPONENT_EXPORT(TRACING_CPP) GetDefaultPerfettoConfig(
-    const base::trace_event::TraceConfig& chrome_config);
+    const base::trace_event::TraceConfig& chrome_config,
+    bool privacy_filtering_enabled = false);
 
 }  // namespace tracing
 

services/tracing/public/cpp/tracing_features.cc

@@ -19,6 +19,11 @@ namespace features {
 const base::Feature kTracingPerfettoBackend{"TracingPerfettoBackend",
                                             base::FEATURE_ENABLED_BY_DEFAULT};
 
+// Causes the BackgroundTracingManager to upload proto messages via UMA,
+// rather than JSON via the crash frontend.
+const base::Feature kBackgroundTracingProtoOutput{
+    "BackgroundTracingProtoOutput", base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Runs the tracing service as an in-process browser service.
 const base::Feature kTracingServiceInProcess {
   "TracingServiceInProcess",

services/tracing/public/cpp/tracing_features.h

@@ -21,6 +21,9 @@ extern const COMPONENT_EXPORT(TRACING_CPP) base::Feature
 extern const COMPONENT_EXPORT(TRACING_CPP) base::Feature
     kTracingServiceInProcess;
 
+extern const COMPONENT_EXPORT(TRACING_CPP) base::Feature
+    kBackgroundTracingProtoOutput;
+
 }  // namespace features
 
 namespace tracing {