Gate the SRTPrompt on a specific FieldTrial group.

chrome/browser/component_updater/sw_reporter_installer_win.cc

 // Copyright (c) 2014 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/component_updater/sw_reporter_installer_win.h"
 
 #include <stdint.h>
 #include <string>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
@@ skipping 48 matching lines @@
                                0x5f, 0xea, 0xf0, 0x88, 0xf6, 0x97, 0x9b, 0xc7};
 
 const base::FilePath::CharType kSwReporterExeName[] =
     FILE_PATH_LITERAL("software_reporter_tool.exe");
 
 // Where to fetch the reporter exit code in the registry.
 const wchar_t kSoftwareRemovalToolRegistryKey[] =
     L"Software\\Google\\Software Removal Tool";
 const wchar_t kExitCodeRegistryValueName[] = L"ExitCode";
 
+// Field trial strings.
+const char kSRTPromptTrialName[] = "SRTPromptFieldTrial";
+const char kSRTPromptOnGroup[] = "On";
+
 // Exit codes that identify that a cleanup is needed.
 const int kCleanupNeeded = 0;
 const int kPostRebootCleanupNeeded = 4;
 
 void ReportUmaStep(SwReporterUmaValue value) {
   UMA_HISTOGRAM_ENUMERATION("SoftwareReporter.Step", value, SW_REPORTER_MAX);
 }
 
 void ReportUmaVersion(const base::Version& version) {
   DCHECK(!version.components().empty());
@@ skipping 22 matching lines @@
 // from the local state. This could be called from an interruptible worker
 // thread so should be resilient to unexpected shutdown. |version| is provided
 // so the kSwReporterPromptVersion prefs can be set.
 void ReportAndClearExitCode(int exit_code, const std::string& version) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("SoftwareReporter.ExitCode", exit_code);
   if (g_browser_process && g_browser_process->local_state()) {
     g_browser_process->local_state()->SetInteger(prefs::kSwReporterLastExitCode,
                                                  exit_code);
   }
 
-  if (exit_code == kPostRebootCleanupNeeded || exit_code == kCleanupNeeded) {
+  if ((exit_code == kPostRebootCleanupNeeded || exit_code == kCleanupNeeded) &&
+      base::FieldTrialList::FindFullName(kSRTPromptTrialName) ==
+          kSRTPromptOnGroup) {
     // Find the last active browser, which may be NULL, in which case we won't
     // show the prompt this time and will wait until the next run of the
     // reporter. We can't use other ways of finding a browser because we don't
     // have a profile.
     chrome::HostDesktopType desktop_type = chrome::GetActiveDesktop();
     Browser* browser = chrome::FindLastActiveWithHostDesktopType(desktop_type);
     if (browser) {
       Profile* profile = browser->profile();
       DCHECK(profile);
       // Now that we have a profile, make sure we have a tabbed browser since we
@@ skipping 168 matching lines @@
   PrefService* prefs_;
   static wchar_t version_dir_[_MAX_PATH];
 };
 
 wchar_t SwReporterInstallerTraits::version_dir_[] = {};
 
 }  // namespace
 
 void RegisterSwReporterComponent(ComponentUpdateService* cus,
                                  PrefService* prefs) {
+  // The Sw reporter doesn't need to run if the user isn't reporting metrics and
+  // isn't in the SRTPrompt field trial "On" group.
+  if (!ChromeMetricsServiceAccessor::IsMetricsReportingEnabled() &&
+      base::FieldTrialList::FindFullName(kSRTPromptTrialName) !=
+          kSRTPromptOnGroup) {
+    return;
+  }
+
   // Install the component.
   scoped_ptr<ComponentInstallerTraits> traits(
       new SwReporterInstallerTraits(prefs));
   // |cus| will take ownership of |installer| during installer->Register(cus).
   DefaultComponentInstaller* installer =
       new DefaultComponentInstaller(traits.Pass());
   installer->Register(cus);
 }
 
 void RegisterPrefsForSwReporter(PrefRegistrySimple* registry) {
   registry->RegisterInt64Pref(prefs::kSwReporterLastTimeTriggered, 0);
   registry->RegisterIntegerPref(prefs::kSwReporterLastExitCode, -1);
 }
 
 void RegisterProfilePrefsForSwReporter(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(
       prefs::kSwReporterPromptReason,
       -1,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   registry->RegisterStringPref(
       prefs::kSwReporterPromptVersion,
       "",
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 }  // namespace component_updater