Background tracing: Added config option for repeated trigger behavior

content/browser/tracing/background_tracing_rule.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_rule.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/rand_util.h"
 #include "base/strings/safe_sprintf.h"
 #include "base/values.h"
 #include "components/tracing/common/tracing_messages.h"
 #include "content/browser/tracing/background_tracing_manager_impl.h"
 #include "content/browser/tracing/trace_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace {
 
 const char kConfigRuleKey[] = "rule";
 const char kConfigCategoryKey[] = "category";
 const char kConfigRuleTriggerNameKey[] = "trigger_name";
 const char kConfigRuleTriggerDelay[] = "trigger_delay";
 const char kConfigRuleTriggerChance[] = "trigger_chance";
+const char kConfigRuleStopTracingOnRepeatedReactive[] =
+    "stop_tracing_on_repeated_reactive";
 
 const char kConfigRuleHistogramNameKey[] = "histogram_name";
 const char kConfigRuleHistogramValueOldKey[] = "histogram_value";
 const char kConfigRuleHistogramValue1Key[] = "histogram_lower_value";
 const char kConfigRuleHistogramValue2Key[] = "histogram_upper_value";
 const char kConfigRuleHistogramRepeatKey[] = "histogram_repeat";
 
 const char kConfigRuleRandomIntervalTimeoutMin[] = "timeout_min";
 const char kConfigRuleRandomIntervalTimeoutMax[] = "timeout_max";
 
@@ skipping 15 matching lines @@
 const int kConfigTypeNavigationTimeout = 30;
 const int kReactiveTraceRandomStartTimeMin = 60;
 const int kReactiveTraceRandomStartTimeMax = 120;
 
 }  // namespace
 
 namespace content {
 
 BackgroundTracingRule::BackgroundTracingRule()
     : trigger_chance_(1.0),
       trigger_delay_(-1),

[ssid, 2016/08/17 04:11:36]

From what I understand:
Probably unrelated to this CL, but this value is set to -1 by default.
Only the navigation config sets this value as 30 seconds. The HistogramRule
constructor never sets this value.
I thought this value was 30 by deafult. The memory triggers do not set this
delay value and we should be starting and stopping tracing immediately?
Or am I missing something? I think I should fix this in the config?

[shatch, 2016/08/17 14:53:58]

Yeah you should probably add a delay in your config, and maybe we want to set a
default in HistogramRule.

+      stop_tracing_on_repeated_reactive_(false),
       category_preset_(BackgroundTracingConfigImpl::CATEGORY_PRESET_UNSET) {}
 
 BackgroundTracingRule::BackgroundTracingRule(int trigger_delay)
     : trigger_chance_(1.0),
       trigger_delay_(trigger_delay),
+      stop_tracing_on_repeated_reactive_(false),
       category_preset_(BackgroundTracingConfigImpl::CATEGORY_PRESET_UNSET) {}
 
 BackgroundTracingRule::~BackgroundTracingRule() {}
 
 bool BackgroundTracingRule::ShouldTriggerNamedEvent(
     const std::string& named_event) const {
   return false;
 }
 
 int BackgroundTracingRule::GetTraceDelay() const {
   return trigger_delay_;
 }
 
 void BackgroundTracingRule::IntoDict(base::DictionaryValue* dict) const {
   DCHECK(dict);
   if (trigger_chance_ < 1.0)
     dict->SetDouble(kConfigRuleTriggerChance, trigger_chance_);
 
   if (trigger_delay_ != -1)
     dict->SetInteger(kConfigRuleTriggerDelay, trigger_delay_);
 
+  if (stop_tracing_on_repeated_reactive_) {
+    dict->SetBoolean(kConfigRuleStopTracingOnRepeatedReactive,
+                     stop_tracing_on_repeated_reactive_);
+  }
+
   if (category_preset_ != BackgroundTracingConfigImpl::CATEGORY_PRESET_UNSET) {
     dict->SetString(
         kConfigCategoryKey,
         BackgroundTracingConfigImpl::CategoryPresetToString(category_preset_));
   }
 }
 
 void BackgroundTracingRule::Setup(const base::DictionaryValue* dict) {
   dict->GetDouble(kConfigRuleTriggerChance, &trigger_chance_);
   dict->GetInteger(kConfigRuleTriggerDelay, &trigger_delay_);
+  dict->GetBoolean(kConfigRuleStopTracingOnRepeatedReactive,
+                   &stop_tracing_on_repeated_reactive_);
 }
 
 namespace {
 
 class NamedTriggerRule : public BackgroundTracingRule {
  private:
   NamedTriggerRule(const std::string& named_event)
       : named_event_(named_event) {}
 
  public:
@@ skipping 290 matching lines @@
     tracing_rule = TraceAtRandomIntervalsRule::Create(dict);
   }
 
   if (tracing_rule)
     tracing_rule->Setup(dict);
 
   return tracing_rule;
 }
 
 }  // namespace content