NOT FOR REVIEW - Slow Reports Reference Implementation

content/browser/tracing/background_tracing_manager_impl.cc

Index: content/browser/tracing/background_tracing_manager_impl.cc
diff --git a/content/browser/tracing/background_tracing_manager_impl.cc b/content/browser/tracing/background_tracing_manager_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..55fa556ae3d564fa972803f14b28a50d4ae8c504
--- /dev/null
+++ b/content/browser/tracing/background_tracing_manager_impl.cc
@@ -0,0 +1,249 @@
+// 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 "content/public/browser/browser_thread.h"
+#include "content/public/browser/tracing_controller.h"
+
+
+namespace content {
+
+namespace {
+
+base::LazyInstance<BackgroundTracingManagerImpl>::Leaky g_controller =
+    LAZY_INSTANCE_INITIALIZER;
+
+class TraceDataEndpointWrapper :
+    public content::TracingController::TraceDataEndpoint {
+ public:
+  TraceDataEndpointWrapper(
+      scoped_refptr<content::BackgroundTracingManager::UploadSink> upload_sink,
+      base::Callback<void()> done_callback) :
+          upload_sink_(upload_sink),
+          done_callback_(done_callback) {
+  }
+
+  void ReceiveTraceFinalContents(const std::string& file_contents) override {
+    upload_sink_->Upload(file_contents, done_callback_);
+  }
+
+ private:
+  ~TraceDataEndpointWrapper() override {
+  }
+
+  scoped_refptr<content::BackgroundTracingManager::UploadSink> upload_sink_;
+  base::Callback<void()> done_callback_;
+};
+
+}  // namespace
+
+BackgroundTracingManager* BackgroundTracingManager::GetInstance() {
+  return BackgroundTracingManagerImpl::GetInstance();
+}
+
+BackgroundTracingManagerImpl* BackgroundTracingManagerImpl::GetInstance() {
+  return g_controller.Pointer();
+}
+
+BackgroundTracingManagerImpl::BackgroundTracingManagerImpl()
+    : is_idle_(true), is_gathering_(false) {
+}
+
+BackgroundTracingManagerImpl::~BackgroundTracingManagerImpl() {
+  NOTREACHED();
+}
+
+void BackgroundTracingManagerImpl::WhenIdle(base::Callback<void()> idle_callback) {

[oystein (OOO til 10th of July), 2015/05/05 19:28:30]

Is this used anywhere? What's it for?

[shatch, 2015/05/05 20:20:22]

Used to notify anybody who's interested that the BackgroundTracingManager is
between traces. Can potentially set a new config at this time.

+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  idle_callback_ = idle_callback;
+}
+
+bool BackgroundTracingManagerImpl::SetActiveScenario(
+      scoped_refptr<BackgroundTracingConfig> config,
+      scoped_refptr<BackgroundTracingManager::UploadSink> upload_sink) {
+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!is_idle_)
+    return false;
+
+  // TODO(simonhatch): Implement reactive tracing path.
+  if (config && config->mode == BackgroundTracingConfig::REACTIVE_TRACING_MODE)
+    return false;
+
+  config_ = config;
+  upload_sink_ = upload_sink;
+
+  MaybeEnableRecording();
+
+  return true;
+}
+
+void BackgroundTracingManagerImpl::MaybeEnableRecording() {
+  if (!config_ || !upload_sink_)
+    return;
+
+  if (config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE) {
+    // HACK
+    EnableRecording(
+        GetCategoryFilterForCategoryPreset(
+            static_cast<BackgroundTracingPreemptiveConfig*>(
+                config_.get())->category_preset));
+  } else {
+    // TODO(simonhatch): Implement reactive tracing path.
+    NOTREACHED();
+  }
+}
+
+bool BackgroundTracingManagerImpl::IsAbleToStartTracing(TriggerHandle handle) const {
+  if (!config_ || !upload_sink_ || is_gathering_)
+    return false;
+
+  if (!IsTriggerHandleValid(handle)) {
+    return false;
+  }
+
+  std::string trigger_name = GetTriggerNameFromHandle(handle);
+
+  if (config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE) {
+    BackgroundTracingPreemptiveConfig* preemptive_config =
+        static_cast<BackgroundTracingPreemptiveConfig*>(config_.get());
+
+    for (size_t i = 0; i < preemptive_config->configs.size(); ++i) {
+      if (preemptive_config->configs[i].type !=
+          BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED)
+        continue;
+
+      if (trigger_name ==
+          preemptive_config->configs[i].named_trigger_info.trigger_name) {
+        return true;
+      }
+    }
+  } else {
+    // TODO(simonhatch): Implement reactive path.
+    NOTREACHED();
+  }
+
+  return false;
+}
+
+void BackgroundTracingManagerImpl::DidTriggerHappen(
+    BackgroundTracingManagerImpl::TriggerHandle handle,
+    StartedFinalizingCallback callback) {
+  if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(
+            &BackgroundTracingManagerImpl::DidTriggerHappen,
+            base::Unretained(this), handle, callback));
+    return;
+  }
+
+  if (!IsAbleToStartTracing(handle)) {
+    if (!callback.is_null())
+      callback.Run(false);
+    return;
+  }
+
+  if (config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE) {
+    BeginFinalizing(callback);
+  } else {
+    // TODO(simonhatch): Implement reactive tracing path.
+    NOTREACHED();
+  }
+}
+
+BackgroundTracingManagerImpl::TriggerHandle
+BackgroundTracingManagerImpl::RegisterTriggerType(const char* trigger_name) {
+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  trigger_handles_.push_back(trigger_name);
+
+  return static_cast<TriggerHandle>(trigger_handles_.size() - 1);
+}
+
+bool BackgroundTracingManagerImpl::IsTriggerHandleValid(
+    BackgroundTracingManager::TriggerHandle handle) const {
+  return handle < trigger_handles_.size();
+}
+
+std::string BackgroundTracingManagerImpl::GetTriggerNameFromHandle(
+    BackgroundTracingManager::TriggerHandle handle) const {
+  CHECK(IsTriggerHandleValid(handle));
+  return trigger_handles_[handle];
+}
+
+void BackgroundTracingManagerImpl::GetTriggerNameList(
+    std::vector<std::string>& trigger_names) {
+  trigger_names = trigger_handles_;
+}
+
+void BackgroundTracingManagerImpl::InvalidateTriggerHandlesForTesting() {
+  trigger_handles_.clear();
+}
+
+void BackgroundTracingManagerImpl::EnableRecording(
+    base::trace_event::CategoryFilter category_filter) {
+  is_idle_ = false;
+  TracingController::GetInstance()->EnableRecording(
+      category_filter,
+      base::trace_event::TraceOptions(base::trace_event::RECORD_CONTINUOUSLY),
+      TracingController::EnableRecordingDoneCallback());
+}
+
+void BackgroundTracingManagerImpl::OnFinalizeComplete() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
+                   base::Unretained(this)));
+    return;
+  }
+
+  printf("BackgroundTracingManagerImpl::OnFinalizeComplete\n");

[oystein (OOO til 10th of July), 2015/05/05 19:28:30]

kill

[shatch, 2015/05/05 20:20:22]

Done.

+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  is_idle_ = true;

[oystein (OOO til 10th of July), 2015/05/05 19:28:30]

Do we need to track this? Can we check if the upload sink is still uploading,
instead of keeping extra state, wherever we currently check this?

[shatch, 2015/05/05 20:20:22]

Added a function on TracingControllerImpl instead.

+
+  if (!idle_callback_.is_null())
+    idle_callback_.Run();
+
+  // Now that a trace has completed, we may need to enable recording again.
+  MaybeEnableRecording();
+}
+
+void BackgroundTracingManagerImpl::BeginFinalizing(
+    StartedFinalizingCallback callback) {
+  is_gathering_ = true;

[oystein (OOO til 10th of July), 2015/05/05 19:28:30]

Can we query the TracingController for this instead? Like if it has a trace data
sink set?

[shatch, 2015/05/05 20:20:22]

Nah there's no way to query that. Will have to add it.

+
+  content::TracingController::GetInstance()->DisableRecording(
+      content::TracingController::CreateCompressedStringSink(
+          new TraceDataEndpointWrapper(

[oystein (OOO til 10th of July), 2015/05/05 19:28:30]

Do we delete this anywhere? Can we store the wrapper instead of the
upload_sink_?

[shatch, 2015/05/05 20:20:22]

CreateCompressedStringSink takes a refptr. Uploaded a version that stores the
wrapper locally, it's more code, see if it looks better or not.

+              upload_sink_,
+              base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
+                         base::Unretained(this)))));
+
+  if (!callback.is_null())
+    callback.Run(true);
+}
+
+base::trace_event::CategoryFilter
+BackgroundTracingManagerImpl::GetCategoryFilterForCategoryPreset(
+    BackgroundTracingConfig::CategoryPreset preset) const {
+  switch (preset) {
+    case BackgroundTracingConfig::CategoryPreset::BENCHMARK:
+      return base::trace_event::CategoryFilter(
+          "benchmark,"
+          "disabled-by-default-toplevel.flow,"
+          "disabled-by-default-ipc.flow");
+    case BackgroundTracingConfig::CategoryPreset::BENCHMARK_DEEP:
+      return base::trace_event::CategoryFilter(
+          "*,disabled-by-default-blink.debug.layout");
+    default:

[oystein (OOO til 10th of July), 2015/05/05 19:28:30]

Maybe without the default label, so we know every preset gets handled. Then move
the NOTREACHED() after the switch().

[shatch, 2015/05/05 20:20:22]

Done.

+      NOTREACHED();
+  }
+  return base::trace_event::CategoryFilter();  
+}
+
+} // namspace content