Add support for the ExperimentalSwReporterEngine field trial.

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 <algorithm>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base_paths.h"
+#include "base/command_line.h"
+#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_tokenizer.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/safe_browsing/srt_fetcher_win.h"
 #include "chrome/browser/safe_browsing/srt_field_trial_win.h"
 #include "components/component_updater/component_updater_paths.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/component_updater/default_component_installer.h"
 #include "components/component_updater/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/utils.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
+#include "third_party/re2/src/re2/re2.h"
 
 namespace component_updater {
 
 namespace {
 
 // These two sets of values are used to send UMA information and are replicated
 // in the histograms.xml file, so the order MUST NOT CHANGE.
 enum SRTCompleted {
   SRT_COMPLETED_NOT_YET = 0,
   SRT_COMPLETED_YES = 1,
@@ skipping 11 matching lines @@
 
 const base::FilePath::CharType kSwReporterExeName[] =
     FILE_PATH_LITERAL("software_reporter_tool.exe");
 
 // SRT registry keys and value names.
 const wchar_t kCleanerSuffixRegistryKey[] = L"Cleaner";
 const wchar_t kExitCodeValueName[] = L"ExitCode";
 const wchar_t kUploadResultsValueName[] = L"UploadResults";
 const wchar_t kVersionValueName[] = L"Version";
 
+// Experiment parameters for the new engine.
+const base::Feature kExperimentalEngineFeature{
+    "ExperimentalSwReporterEngine", base::FEATURE_DISABLED_BY_DEFAULT};
+
+const char kExperimentalEngineTagParam[] = "tag";
+const re2::RE2 kExperimentalEngineArgsParam = "args(\\d+)";
+const re2::RE2 kExperimentalEngineSuffixParam = "suffix(\\d+)";
+
 void SRTHasCompleted(SRTCompleted value) {
   UMA_HISTOGRAM_ENUMERATION("SoftwareReporter.Cleaner.HasCompleted", value,
                             SRT_COMPLETED_MAX);
 }
 
 void ReportUploadsWithUma(const base::string16& upload_results) {
   base::WStringTokenizer tokenizer(upload_results, L";");
   int failure_count = 0;
   int success_count = 0;
   int longest_failure_run = 0;
@@ skipping 16 matching lines @@
 
   UMA_HISTOGRAM_COUNTS_100("SoftwareReporter.UploadFailureCount",
                            failure_count);
   UMA_HISTOGRAM_COUNTS_100("SoftwareReporter.UploadSuccessCount",
                            success_count);
   UMA_HISTOGRAM_COUNTS_100("SoftwareReporter.UploadLongestFailureRun",
                            longest_failure_run);
   UMA_HISTOGRAM_BOOLEAN("SoftwareReporter.LastUploadResult", last_result);
 }
 
+bool IsExperimentalEngineEnabled() {
+  // The experiment is only enabled on x86. Finch doesn't have a way to check
+  // this so we'll hard-code it.
+  if (base::SysInfo::OperatingSystemArchitecture() != "x86")
+    return false;
+
+  return base::FeatureList::IsEnabled(kExperimentalEngineFeature);
+}
+
 class SwReporterInstallerTraits : public ComponentInstallerTraits {
  public:
   SwReporterInstallerTraits() {}
 
   ~SwReporterInstallerTraits() override {}
 
   bool VerifyInstallation(const base::DictionaryValue& manifest,
                           const base::FilePath& dir) const override {
     return base::PathExists(dir.Append(kSwReporterExeName));
   }
 
   bool SupportsGroupPolicyEnabledComponentUpdates() const override {
     return true;
   }
 
   bool RequiresNetworkEncryption() const override { return false; }
 
   bool OnCustomInstall(const base::DictionaryValue& manifest,
                        const base::FilePath& install_dir) override {
     return true;
   }
 
   void ComponentReady(
       const base::Version& version,
       const base::FilePath& install_dir,
       std::unique_ptr<base::DictionaryValue> manifest) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-    safe_browsing::RunSwReporter(install_dir.Append(kSwReporterExeName),
-                                 version, base::ThreadTaskRunnerHandle::Get(),
+
+    base::FilePath exe_path(install_dir.Append(kSwReporterExeName));
+
+    // If this user is getting the experimental engine, read the command-line
+    // params and an UMA histogram suffix from the experiment parameters.
+    if (IsExperimentalEngineEnabled()) {
+      // TODO(joenotcharles): check the version or manifest to make sure we
+      // actually got an experimental version (unless in the control group).
+      std::vector<safe_browsing::SwReporterInvocation> invocations;
+
+      // Command-line arguments are passed as args0, args1, ..., argsN.
+      // Suffixes are passed as suffix0, suffix1, ..., suffixN.
+      //
+      // Read all the parameters whose names match these patterns into maps,
+      // then make sure that all indices 0 through N are stored in both maps.
+      // If any are missing, the experiment config is badly formatted. If it's
+      // ok, add each pair (command line, suffix) to the invocations vector.
+      std::map<std::string, std::string> experiment_params;
+      if (variations::GetVariationParamsByFeature(kExperimentalEngineFeature,
+                                                  &experiment_params)) {
+        std::map<int, std::string> arg_strings;
+        std::map<int, std::string> suffixes;
+        unsigned int max_index = 0;
+        for (const auto& param : experiment_params) {
+          unsigned int index = 0;
+          if (re2::RE2::FullMatch(param.first, kExperimentalEngineArgsParam,
+                                  &index)) {
+            arg_strings[index] = param.second;
+            max_index = std::max(index, max_index);
+          } else if (re2::RE2::FullMatch(param.first,
+                kExperimentalEngineSuffixParam, &index)) {
+            suffixes[index] = param.second;
+            max_index = std::max(index, max_index);
+          }
+        }
+
+        invocations.reserve(max_index + 1);
+        for (unsigned int i = 0; i < max_index; ++i) {
+          auto args = arg_strings.find(i);
+          auto suffix = suffixes.find(i);
+          if (args == arg_strings.end() ||
+              suffix == suffixes.end()) {
+            // TODO(joenotcharles): Report bad finch config.
+            invocations.clear();
+            break;
+          }
+
+          // Construct the command-line using a placeholder which is guaranteed
+          // not to need quoting for arg 0. Then replace it with the real path,
+          // which may contain spaces and other weirdness.
+          auto command_line = base::CommandLine::FromString(base::UTF8ToUTF16(
+                base::StringPrintf("%s %s", kSwReporterExeName, args->second)));
+          command_line.SetProgram(exe_path);
+
+          // Add the histogram suffix to the command-line as well, so that the
+          // reporter will add the same suffix to registry keys where it writes
+          // metrics.
+          command_line.AppendSwitchNative("registry-suffix",
+                                          base::UTF8ToUTF16(suffix->second));

[Joe Mason, 2016/08/09 15:24:26]

pmbureau: This is what I was talking about in the meeting yesterday. The
reporter would need to read this "registry-suffix" switch and add the value to
the registry keys it writes to (see "RegistryKeyWithSuffix" below for the code
where chrome reads from those keys).

+
+          invocations[i] = safe_browsing::SwReporterInvocation(
+              command_line, suffix->second);
+        }
+      }
+
+      // If there were no explicit command-lines found, fall through to the
+      // default invocation which is the binary name without arguments.
+      if (!invocations.empty()) {
+        safe_browsing::RunExperimentalSwReporters(invocations, version,
+            base::ThreadTaskRunnerHandle::Get(),
+            base::WorkerPool::GetTaskRunner(true));
+        return;
+      }
+    }
+
+    safe_browsing::RunSwReporter(exe_path, version,
+                                 base::ThreadTaskRunnerHandle::Get(),
                                  base::WorkerPool::GetTaskRunner(true));
   }
 
   base::FilePath GetRelativeInstallDir() const override {
     return base::FilePath(FILE_PATH_LITERAL("SwReporter"));
   }
 
   void GetHash(std::vector<uint8_t>* hash) const override { GetPkHash(hash); }
 
   std::string GetName() const override { return "Software Reporter Tool"; }
 
   update_client::InstallerAttributes GetInstallerAttributes() const override {
-    return update_client::InstallerAttributes();
+    update_client::InstallerAttributes attributes;
+    if (IsExperimentalEngineEnabled()) {
+      // Pass the "tag" parameter to the installer; it will be used to choose
+      // which binary is downloaded.
+      std::string tag = variations::GetVariationParamValueByFeature(
+          kExperimentalEngineFeature, kExperimentalEngineTagParam);
+      if (!tag.empty())
+        attributes[kExperimentalEngineTagParam] = tag;
+    }
+    return attributes;
   }
   std::vector<std::string> GetMimeTypes() const override {
     return std::vector<std::string>();
   }
 
   static std::string ID() {
     update_client::CrxComponent component;
     component.version = Version("0.0.0.0");
     GetPkHash(&component.pk_hash);
     return update_client::GetCrxComponentID(component);
@@ skipping 100 matching lines @@
 }
 
 void RegisterProfilePrefsForSwReporter(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterStringPref(prefs::kSwReporterPromptVersion, "");
 
   registry->RegisterStringPref(prefs::kSwReporterPromptSeed, "");
 }
 
 }  // namespace component_updater