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 B
|
+ 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 uplo
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 instea
shatch
2015/05/05 20:20:22
Nah there's no way to query that. Will have to add
|
+ |
+ 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 wrapp
shatch
2015/05/05 20:20:22
CreateCompressedStringSink takes a refptr. Uploade
|
+ 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
shatch
2015/05/05 20:20:22
Done.
|
+ NOTREACHED(); |
+ } |
+ return base::trace_event::CategoryFilter(); |
+} |
+ |
+} // namspace content |