Adding local field trial for metrics/crash reports sampling.

chrome/browser/metrics/chrome_metrics_services_manager_client.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 "chrome/browser/metrics/chrome_metrics_services_manager_client.h"
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 45 matching lines @@
                                              base::FEATURE_ENABLED_BY_DEFAULT};
 
 // Posts |GoogleUpdateSettings::StoreMetricsClientInfo| on blocking pool thread
 // because it needs access to IO and cannot work from UI thread.
 void PostStoreMetricsClientInfo(const metrics::ClientInfo& client_info) {
   content::BrowserThread::GetBlockingPool()->PostTask(
       FROM_HERE,
       base::Bind(&GoogleUpdateSettings::StoreMetricsClientInfo, client_info));
 }
 
+// Appends a group to the sampling controlling |trial|. The group will be
+// associated with a variation param for reporting samlping |rate| in per mille.
+void AppendSamplingTrialGroup(const std::string& name,
+                              int rate,
+                              base::FieldTrial* trial) {
+  std::map<std::string, std::string> params = {
+      {kRateParamName, base::IntToString(rate)}};
+  variations::AssociateVariationParams(trial->trial_name(), name, params);
+  trial->AppendGroup(name, rate);
+}
+
 // Only clients that were given an opt-out metrics-reporting consent flow are
 // eligible for sampling.
 bool IsClientEligibleForSampling() {
   return metrics::GetMetricsReportingDefaultState(
              g_browser_process->local_state()) ==
          metrics::EnableMetricsDefault::OPT_OUT;
 }
 
 }  // namespace
 
@@ skipping 20 matching lines @@
     PrefService* local_state)
     : enabled_state_provider_(new ChromeEnabledStateProvider()),
       local_state_(local_state) {
   DCHECK(local_state);
 
   SetupMetricsStateForChromeOS();
 }
 
 ChromeMetricsServicesManagerClient::~ChromeMetricsServicesManagerClient() {}
 
+#if defined(OS_WIN) || defined(OS_ANDROID)
+// static
+void ChromeMetricsServicesManagerClient::CreateFallbackSamplingTrial(
+    base::FeatureList* feature_list) {
+  const std::string kTrialName = "MetricsAndCrashSampling";

[Alexei Svitkine (slow), 2016/08/29 19:38:42]

static const char[]

same for the other ones below

[jwd, 2016/08/29 21:36:24]

Done.

+  scoped_refptr<base::FieldTrial> trial(
+      base::FieldTrialList::FactoryGetFieldTrial(
+          kTrialName, 1000, "Default", base::FieldTrialList::kNoExpirationYear,
+          1, 1, base::FieldTrial::ONE_TIME_RANDOMIZED, NULL));
+
+  // 100 per-mille sampling rate group.
+  const std::string kInSampleGroup = "InReportingSample";
+  AppendSamplingTrialGroup(kInSampleGroup, 100, trial.get());
+
+  // 900 per-mille sampled out.
+  const std::string kSampledOutGroup = "OutOfReportingSample";
+  AppendSamplingTrialGroup(kSampledOutGroup, 900, trial.get());
+
+  // Setup the feature.
+  const std::string& group_name = trial->GetGroupNameWithoutActivation();
+  feature_list->RegisterFieldTrialOverride(
+      kMetricsReportingFeature.name,
+      group_name == kSampledOutGroup
+          ? base::FeatureList::OVERRIDE_DISABLE_FEATURE
+          : base::FeatureList::OVERRIDE_ENABLE_FEATURE,
+      trial.get());
+}
+#endif  // defined(OS_WIN) || defined(OS_ANDROID)
+
 // static
 bool ChromeMetricsServicesManagerClient::IsClientInSample() {
   // Only some clients are eligible for sampling. Clients that aren't eligible
   // will always be considered "in sample". In this case, we don't want the
   // feature state queried, because we don't want the field trial that controls
   // sampling to be reported as active.
   if (!IsClientEligibleForSampling())
     return true;
 
   return base::FeatureList::IsEnabled(kMetricsReportingFeature);
@@ skipping 102 matching lines @@
 ChromeMetricsServicesManagerClient::GetMetricsStateManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!metrics_state_manager_) {
     metrics_state_manager_ = metrics::MetricsStateManager::Create(
         local_state_, enabled_state_provider_.get(),
         base::Bind(&PostStoreMetricsClientInfo),
         base::Bind(&GoogleUpdateSettings::LoadMetricsClientInfo));
   }
   return metrics_state_manager_.get();
 }