Revert of First pass BackgroundTracingManager. (patchset #15 id:450001 of...

Revert of First pass BackgroundTracingManager. (patchset #15 id:450001 of https://codereview.chromium.org/1089253003/)

Reason for revert:
Failed TSan Tests.

http://build.chromium.org/p/chromium.memory.fyi/builders/Linux%20TSan%20Tests/builds/4795

Original issue's description:
> Skeleton for BackgroundTracingManager.
>
> This version mostly just directs the TracingController using the specified BackgroundTracingConfig and pushes the compressed trace out to the BackgroundTracingUploadSink.
>
> Specifically, we implement the PREEMPTIVE_TRACING_MODE for the rule MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED, which should allow us to get an experiment going on desktop with a simple trigger and upload.
>
> We can then follow up with additional CL's implementing the rest of the functionality from the clientside doc below.
>
> Needs to land first: https://codereview.chromium.org/1088673003/
>
> Slow Reports Clientside: https://docs.google.com/document/d/1qZmXmodxOKmsTRO27z2WlH2h9Kpf-kjV-k-1pJIogIE/edit?pli=1
>
> go/slow-reports
>
> Committed: https://crrev.com/c9cd43c8963301a6b1ebfb74c4eb03b8c733e9f9
> Cr-Commit-Position: refs/heads/master@{#330942}

TBR=dsinclair@chromium.org,nduca@chromium.org,oysteine@chromium.org,sievers@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1147383002

Cr-Commit-Position: refs/heads/master@{#330949}

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/macros.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"
-
-namespace content {
-
-namespace {
-
-base::LazyInstance<BackgroundTracingManagerImpl>::Leaky g_controller =
-    LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
-BackgroundTracingManagerImpl::TraceDataEndpointWrapper::
-    TraceDataEndpointWrapper(base::Callback<
-        void(scoped_refptr<base::RefCountedString>)> done_callback)
-    : done_callback_(done_callback) {
-}
-
-BackgroundTracingManagerImpl::TraceDataEndpointWrapper::
-    ~TraceDataEndpointWrapper() {
-}
-
-void BackgroundTracingManagerImpl::TraceDataEndpointWrapper::
-    ReceiveTraceFinalContents(const std::string& file_contents) {
-  std::string tmp = file_contents;
-  scoped_refptr<base::RefCountedString> contents_ptr =
-      base::RefCountedString::TakeString(&tmp);
-
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(done_callback_, contents_ptr));
-}
-
-BackgroundTracingManager* BackgroundTracingManager::GetInstance() {
-  return BackgroundTracingManagerImpl::GetInstance();
-}
-
-BackgroundTracingManagerImpl* BackgroundTracingManagerImpl::GetInstance() {
-  return g_controller.Pointer();
-}
-
-BackgroundTracingManagerImpl::BackgroundTracingManagerImpl()
-    : is_gathering_(false),
-      is_tracing_(false),
-      requires_anonymized_data_(true),
-      trigger_handle_ids_(0) {
-  data_endpoint_wrapper_ = new TraceDataEndpointWrapper(
-      base::Bind(&BackgroundTracingManagerImpl::OnFinalizeStarted,
-                 base::Unretained(this)));
-}
-
-BackgroundTracingManagerImpl::~BackgroundTracingManagerImpl() {
-  NOTREACHED();
-}
-
-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)
-    return true;
-
-  // TODO(simonhatch): Implement reactive tracing path.
-  if (config->mode != BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE)
-    return false;
-
-  // TODO(fmeawad): Implement uma triggers.
-  BackgroundTracingPreemptiveConfig* preemptive_config =
-      static_cast<BackgroundTracingPreemptiveConfig*>(config);
-  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_TRIGGER_NAMED)
-      return false;
-  }
-
-  return true;
-}
-
-bool BackgroundTracingManagerImpl::SetActiveScenario(
-    scoped_ptr<BackgroundTracingConfig> config,
-    const BackgroundTracingManager::ReceiveCallback& receive_callback,
-    bool requires_anonymized_data) {
-  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (is_tracing_)
-    return false;
-
-  if (!IsSupportedConfig(config.get()))
-    return false;
-
-  // No point in tracing if there's nowhere to send it.
-  if (config && receive_callback.is_null())
-    return false;
-
-  config_ = config.Pass();
-  receive_callback_ = receive_callback;
-  requires_anonymized_data_ = requires_anonymized_data;
-
-  EnableRecordingIfConfigNeedsIt();
-
-  return true;
-}
-
-void BackgroundTracingManagerImpl::EnableRecordingIfConfigNeedsIt() {
-  if (!config_)
-    return;
-
-  if (config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE) {
-    EnableRecording(GetCategoryFilterForCategoryPreset(
-        static_cast<BackgroundTracingPreemptiveConfig*>(config_.get())
-            ->category_preset));
-  } else {
-    // TODO(simonhatch): Implement reactive tracing path.
-    NOTREACHED();
-  }
-}
-
-bool BackgroundTracingManagerImpl::IsAbleToTriggerTracing(
-    TriggerHandle handle) const {
-  if (!config_)
-    return false;
-
-  // If the last trace is still uploading, we don't allow a new one to trigger.
-  if (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());
-
-    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_TRIGGER_NAMED)
-        continue;
-
-      if (trigger_name == configs[i].named_trigger_info.trigger_name) {
-        return true;
-      }
-    }
-  } else {
-    // TODO(simonhatch): Implement reactive path.
-    NOTREACHED();
-  }
-
-  return false;
-}
-
-void BackgroundTracingManagerImpl::TriggerNamedEvent(
-    BackgroundTracingManagerImpl::TriggerHandle handle,
-    StartedFinalizingCallback callback) {
-  if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&BackgroundTracingManagerImpl::TriggerNamedEvent,
-                   base::Unretained(this), handle, callback));
-    return;
-  }
-
-  if (!IsAbleToTriggerTracing(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_handle_ids_ += 1;
-
-  trigger_handles_.insert(
-      std::pair<TriggerHandle, std::string>(trigger_handle_ids_, trigger_name));
-
-  return static_cast<TriggerHandle>(trigger_handle_ids_);
-}
-
-bool BackgroundTracingManagerImpl::IsTriggerHandleValid(
-    BackgroundTracingManager::TriggerHandle handle) const {
-  return trigger_handles_.find(handle) != trigger_handles_.end();
-}
-
-std::string BackgroundTracingManagerImpl::GetTriggerNameFromHandle(
-    BackgroundTracingManager::TriggerHandle handle) const {
-  CHECK(IsTriggerHandleValid(handle));
-  return trigger_handles_.find(handle)->second;
-}
-
-void BackgroundTracingManagerImpl::GetTriggerNameList(
-    std::vector<std::string>* trigger_names) {
-  for (std::map<TriggerHandle, std::string>::iterator it =
-           trigger_handles_.begin();
-       it != trigger_handles_.end(); ++it)
-    trigger_names->push_back(it->second);
-}
-
-void BackgroundTracingManagerImpl::InvalidateTriggerHandlesForTesting() {
-  trigger_handles_.clear();
-}
-
-void BackgroundTracingManagerImpl::EnableRecording(
-    base::trace_event::CategoryFilter category_filter) {
-  is_tracing_ = TracingController::GetInstance()->EnableRecording(
-      category_filter,
-      base::trace_event::TraceOptions(base::trace_event::RECORD_CONTINUOUSLY),
-      TracingController::EnableRecordingDoneCallback());
-}
-
-void BackgroundTracingManagerImpl::OnFinalizeStarted(
-    scoped_refptr<base::RefCountedString> file_contents) {
-  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  if (!receive_callback_.is_null())
-    receive_callback_.Run(
-        file_contents.get(),
-        base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
-                   base::Unretained(this)));
-}
-
-void BackgroundTracingManagerImpl::OnFinalizeComplete() {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
-                   base::Unretained(this)));
-    return;
-  }
-
-  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  is_gathering_ = false;
-
-  if (!idle_callback_.is_null())
-    idle_callback_.Run();
-
-  // Now that a trace has completed, we may need to enable recording again.
-  EnableRecordingIfConfigNeedsIt();
-}
-
-void BackgroundTracingManagerImpl::BeginFinalizing(
-    StartedFinalizingCallback callback) {
-  is_gathering_ = true;
-  is_tracing_ = false;
-
-  content::TracingController::GetInstance()->DisableRecording(
-      content::TracingController::CreateCompressedStringSink(
-          data_endpoint_wrapper_));
-
-  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");
-  }
-  NOTREACHED();
-  return base::trace_event::CategoryFilter();
-}
-
-BackgroundTracingConfig* BackgroundTracingConfig::FromDict(
-    const base::DictionaryValue* dict) {
-  // TODO(simonhatch): Implement this.
-  CHECK(false);
-  return NULL;
-}
-
-void BackgroundTracingConfig::IntoDict(const BackgroundTracingConfig* config,
-                                       base::DictionaryValue* dict) {
-  // TODO(simonhatch): Implement this.
-  CHECK(false);
-}
-
-}  // namspace content

content/browser/tracing/background_tracing_manager_impl.h

-// 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.
-
-#ifndef CONTENT_BROWSER_TRACING_BACKGROUND_TRACING_MANAGER_IMPL_H_
-#define CONTENT_BROWSER_TRACING_BACKGROUND_TRACING_MANAGER_IMPL_H_
-
-#include "base/lazy_instance.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "content/browser/tracing/tracing_controller_impl.h"
-#include "content/public/browser/background_tracing_config.h"
-#include "content/public/browser/background_tracing_manager.h"
-
-namespace content {
-
-class BackgroundTracingManagerImpl : public content::BackgroundTracingManager {
- public:
-  static BackgroundTracingManagerImpl* GetInstance();
-
-  bool SetActiveScenario(scoped_ptr<BackgroundTracingConfig>,
-                         const ReceiveCallback&,
-                         bool) override;
-  void WhenIdle(IdleCallback idle_callback) override;
-
-  void TriggerNamedEvent(TriggerHandle, StartedFinalizingCallback) override;
-  TriggerHandle RegisterTriggerType(const char* trigger_name) override;
-  void GetTriggerNameList(std::vector<std::string>* trigger_names) override;
-
-  void InvalidateTriggerHandlesForTesting() override;
-
- private:
-  BackgroundTracingManagerImpl();
-  ~BackgroundTracingManagerImpl() override;
-
-  void EnableRecording(base::trace_event::CategoryFilter);
-  void EnableRecordingIfConfigNeedsIt();
-  void OnFinalizeStarted(scoped_refptr<base::RefCountedString>);
-  void OnFinalizeComplete();
-  void BeginFinalizing(StartedFinalizingCallback);
-
-  std::string GetTriggerNameFromHandle(TriggerHandle handle) const;
-  bool IsTriggerHandleValid(TriggerHandle handle) const;
-
-  bool IsAbleToTriggerTracing(TriggerHandle handle) const;
-  bool IsSupportedConfig(BackgroundTracingConfig* config);
-
-  base::trace_event::CategoryFilter GetCategoryFilterForCategoryPreset(
-      BackgroundTracingConfig::CategoryPreset) const;
-
-  class TraceDataEndpointWrapper
-      : public content::TracingController::TraceDataEndpoint {
-   public:
-    TraceDataEndpointWrapper(base::Callback<
-        void(scoped_refptr<base::RefCountedString>)> done_callback);
-
-    void ReceiveTraceFinalContents(const std::string& file_contents) override;
-
-   private:
-    ~TraceDataEndpointWrapper() override;
-
-    base::Callback<void(scoped_refptr<base::RefCountedString>)> done_callback_;
-  };
-
-  scoped_ptr<content::BackgroundTracingConfig> config_;
-  scoped_refptr<TraceDataEndpointWrapper> data_endpoint_wrapper_;
-  std::map<TriggerHandle, std::string> trigger_handles_;
-  ReceiveCallback receive_callback_;
-
-  bool is_gathering_;
-  bool is_tracing_;
-  bool requires_anonymized_data_;
-  int trigger_handle_ids_;
-
-  IdleCallback idle_callback_;
-
-  friend struct base::DefaultLazyInstanceTraits<BackgroundTracingManagerImpl>;
-
-  DISALLOW_COPY_AND_ASSIGN(BackgroundTracingManagerImpl);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_TRACING_BACKGROUND_TRACING_MANAGER_IMPL_H_

content/content_browser.gypi

@@ -70,13 +70,6 @@
       'public/browser/appcache_service.h',
       'public/browser/ax_event_notification_details.cc',
       'public/browser/ax_event_notification_details.h',
-      'public/browser/background_tracing_config.cc',
-      'public/browser/background_tracing_config.h',
-      'public/browser/background_tracing_manager.h',
-      'public/browser/background_tracing_preemptive_config.cc',
-      'public/browser/background_tracing_preemptive_config.h',
-      'public/browser/background_tracing_reactive_config.cc',
-      'public/browser/background_tracing_reactive_config.h',
       'public/browser/blob_handle.h',
       'public/browser/browser_accessibility_state.h',
       'public/browser/browser_child_process_host.h',
@@ -1455,8 +1448,6 @@
       'browser/time_zone_monitor_linux.cc',
       'browser/time_zone_monitor_mac.mm',
       'browser/time_zone_monitor_win.cc',
-      'browser/tracing/background_tracing_manager_impl.cc',
-      'browser/tracing/background_tracing_manager_impl.h',
       'browser/tracing/etw_system_event_consumer_win.cc',
       'browser/tracing/etw_system_event_consumer_win.h',
       'browser/tracing/file_tracing_provider_impl.cc',

content/content_tests.gypi

@@ -239,7 +239,6 @@
       'browser/shared_worker/worker_browsertest.cc',
       'browser/site_per_process_browsertest.cc',
       'browser/site_per_process_browsertest.h',
-      'browser/tracing/background_tracing_manager_browsertest.cc',
       'browser/tracing/tracing_controller_browsertest.cc',
       'browser/web_contents/opened_by_dom_browsertest.cc',
       'browser/web_contents/touch_editable_impl_aura_browsertest.cc',

content/public/browser/background_tracing_config.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/public/browser/background_tracing_config.h"
-
-namespace content {
-
-BackgroundTracingConfig::BackgroundTracingConfig(Mode mode) : mode(mode) {
-}
-
-BackgroundTracingConfig::~BackgroundTracingConfig() {
-}
-
-}  // namespace content

content/public/browser/background_tracing_config.h

-// 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.
-
-#ifndef CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_CONFIG_H_
-#define CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_CONFIG_H_
-
-#include "base/trace_event/trace_event_impl.h"
-#include "content/common/content_export.h"
-
-namespace base {
-class DictionaryValue;
-}
-
-namespace content {
-
-// BackgroundTracingConfig is passed to the BackgroundTracingManager to
-// setup the trigger rules used to enable/disable background tracing.
-struct CONTENT_EXPORT BackgroundTracingConfig {
-  virtual ~BackgroundTracingConfig();
-
-  enum Mode {
-    PREEMPTIVE_TRACING_MODE,
-    REACTIVE_TRACING_MODE,
-  };
-  enum CategoryPreset {
-    BENCHMARK,
-    BENCHMARK_DEEP,
-  };
-
-  Mode mode;
-
-  static BackgroundTracingConfig* FromDict(const base::DictionaryValue* dict);
-  static void IntoDict(const BackgroundTracingConfig* config,
-                       base::DictionaryValue* dict);
-
- protected:
-  BackgroundTracingConfig(Mode mode);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_CONFIG_H_

content/public/browser/background_tracing_manager.h

-// 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.
-
-#ifndef CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_MANAGER_H_
-#define CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_MANAGER_H_
-
-#include "base/trace_event/trace_event_impl.h"
-#include "base/values.h"
-#include "content/common/content_export.h"
-
-namespace content {
-struct BackgroundTracingConfig;
-struct BackgroundTracingUploadConfig;
-
-// BackgroundTracingManager is used on the browser process to trigger the
-// collection of trace data and upload the results. Only the browser UI thread
-// is allowed to interact with the BackgroundTracingManager. All callbacks are
-// called on the UI thread.
-class BackgroundTracingManager {
- public:
-  CONTENT_EXPORT static BackgroundTracingManager* GetInstance();
-
-  // ReceiveCallback will will be called on the UI thread every time the
-  // BackgroundTracingManager finalizes a trace. The first parameter of
-  // this callback is the trace data. The second is a callback to
-  // notify the BackgroundTracingManager that you've finished processing
-  // the trace data.
-  //
-  // Example:
-  //
-  // void Upload(const base::RefCountedString* data,
-  //             base::Closure done_callback) {
-  //   BrowserThread::PostTaskAndReply(
-  //       BrowserThread::FILE,
-  //       FROM_HERE,
-  //       base::Bind(&DoUploadOnFileThread, data),
-  //       done_callback
-  //     );
-  // }
-  //
-  typedef base::Callback<void(const base::RefCountedString*, base::Closure)>
-      ReceiveCallback;
-
-  // Set the triggering rules for when to start recording.
-  //
-  // In preemptive mode, recording begins immediately and any calls to
-  // TriggerNamedEvent() will potentially trigger the trace to finalize and get
-  // uploaded to the specified upload_sink. Once the trace has been uploaded,
-  // tracing will be enabled again.
-  //
-  // In reactive mode, recording begins when TriggerNamedEvent() is called, and
-  // continues until either the next call to TriggerNamedEvent, or a timeout
-  // occurs. Tracing will not be re-enabled after the trace is finalized and
-  // uploaded to the upload_sink.
-  //
-  // Calls to SetActiveScenario() with a config will fail if tracing is
-  // currently on. Use WhenIdle to register a callback to get notified when
-  // the manager is idle and a config can be set again.
-  virtual bool SetActiveScenario(scoped_ptr<BackgroundTracingConfig> config,
-                                 const ReceiveCallback& receive_callback,
-                                 bool requires_anonymized_data) = 0;
-
-  // Notifies the caller when the manager is idle (not recording or uploading),
-  // so that a call to SetActiveScenario() is likely to succeed.
-  typedef base::Callback<void()> IdleCallback;
-  virtual void WhenIdle(IdleCallback idle_callback) = 0;
-
-  typedef base::Callback<void(bool)> StartedFinalizingCallback;
-  typedef int TriggerHandle;
-
-  // Notifies that a manual trigger event has occurred, and we may need to
-  // either begin recording or finalize the trace, depending on the config.
-  // If the trigger specified isn't active in the config, this will do nothing.
-  virtual void TriggerNamedEvent(
-      TriggerHandle trigger_handle,
-      StartedFinalizingCallback started_callback) = 0;
-
-  // Registers a manual trigger handle, and returns a TriggerHandle which can
-  // be passed to DidTriggerHappen().
-  virtual TriggerHandle RegisterTriggerType(const char* trigger_name) = 0;
-
-  // Returns a list of all registered triggers.
-  virtual void GetTriggerNameList(std::vector<std::string>* trigger_names) = 0;
-
-  virtual void InvalidateTriggerHandlesForTesting() = 0;
-
- protected:
-  virtual ~BackgroundTracingManager() {}
-};
-
-}  // namespace content
-
-#endif  // CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_MANAGER_H_

content/public/browser/background_tracing_preemptive_config.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/public/browser/background_tracing_preemptive_config.h"
-
-namespace content {
-
-BackgroundTracingPreemptiveConfig::BackgroundTracingPreemptiveConfig()
-    : BackgroundTracingConfig(BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE),
-      category_preset(BackgroundTracingConfig::BENCHMARK) {
-}
-
-BackgroundTracingPreemptiveConfig::~BackgroundTracingPreemptiveConfig() {
-}
-
-}  // namespace content

content/public/browser/background_tracing_preemptive_config.h

-// 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.
-
-#ifndef CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_PREEMPTIVE_CONFIG_H_
-#define CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_PREEMPTIVE_CONFIG_H_
-
-#include "content/public/browser/background_tracing_config.h"
-
-namespace content {
-
-// BackgroundTracingPreemptiveConfig holds trigger rules for use during
-// preemptive tracing. Tracing will be enabled immediately, and whenever
-// a trigger occurs, the trace will be finalized.
-struct CONTENT_EXPORT BackgroundTracingPreemptiveConfig
-    : public BackgroundTracingConfig {
- public:
-  BackgroundTracingPreemptiveConfig();
-  ~BackgroundTracingPreemptiveConfig() override;
-
-  enum RuleType {
-    MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED,
-    MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE,
-    MONITOR_AND_DUMP_WHEN_BROWSER_STARTUP_COMPLETE,
-  };
-  struct HistogramTriggerInfo {
-    std::string histogram_name_to_trigger_on;
-    int histogram_bin_to_trigger_on;
-  };
-  struct NamedTriggerInfo {
-    std::string trigger_name;
-  };
-  struct MonitoringRule {
-    RuleType type;
-    HistogramTriggerInfo histogram_trigger_info;
-    NamedTriggerInfo named_trigger_info;
-  };
-
-  std::vector<MonitoringRule> configs;
-  CategoryPreset category_preset;
-};
-
-}  // namespace content
-
-#endif  // CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_PREEMPTIVE_CONFIG_H_

content/public/browser/background_tracing_reactive_config.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/public/browser/background_tracing_reactive_config.h"
-
-namespace content {
-
-BackgroundTracingReactiveConfig::BackgroundTracingReactiveConfig()
-    : BackgroundTracingConfig(BackgroundTracingConfig::REACTIVE_TRACING_MODE) {
-}
-
-BackgroundTracingReactiveConfig::~BackgroundTracingReactiveConfig() {
-}
-
-}  // namespace content

content/public/browser/background_tracing_reactive_config.h

-// 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.
-
-#ifndef CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_REACTIVE_CONFIG_H_
-#define CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_REACTIVE_CONFIG_H_
-
-#include "content/public/browser/background_tracing_config.h"
-
-namespace content {
-
-// BackgroundTracingReactiveConfig holds trigger rules for use during
-// reactive tracing. Tracing will be not be enabled immediately, rather
-// the BackgroundTracingManager will wait for a trigger to occur, and
-// enable tracing at that point. Tracing will be finalized later, either
-// after some time has elapsed or the trigger occurs again.
-struct CONTENT_EXPORT BackgroundTracingReactiveConfig
-    : public BackgroundTracingConfig {
- public:
-  BackgroundTracingReactiveConfig();
-  ~BackgroundTracingReactiveConfig() override;
-
-  enum RuleType { TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL };
-  struct TracingRule {
-    RuleType type;
-    std::string trigger_name;
-    CategoryPreset category_preset;
-  };
-
-  std::vector<TracingRule> configs;
-};
-
-}  // namespace content
-
-#endif  // CONTENT_PUBLIC_BROWSER_BACKGROUND_TRACING_REACTIVE_CONFIG_H_