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";
 
+const base::Feature kExperimentalEngineFeature{
+    "ExperimentalSwReporterEngine", base::FEATURE_DISABLED_BY_DEFAULT};
+
 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

[grt (UTC plus 2), 2016/08/10 06:47:01]

nit: please avoid "finch" if possible. i suggest:

  // This experiment only applies to x86. Make this explicit, as field trials
cannot target specific architectures.

[Joe Mason, 2016/08/15 17:24:39]

Done.

+  // 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;

[grt (UTC plus 2), 2016/08/10 06:47:01]

the items in this vector are copied wholesale each time it is bound into a
callback and each time one item is pulled off. since this is treated as queue, a
std::queue backed by a std::list would be more efficient for mutations, and
passing ownership of the queue (via a std::unique_ptr) as it bounces around
would keep you with a single instance (rather than copies).

[Joe Mason, 2016/08/15 17:24:39]

I'll switch to a queue, since the interface makes more sense for the behaviour,
but I don't think unique_ptr is a good idea. It makes memory handling more
complicated as the queue gets passed between two classes and a chain of
callbacks, and the cost of copying the queue is negligable: we expect it to have
3-5 elements at most, and none of this is in a hot path.

[grt (UTC plus 2), 2016/08/15 19:39:39]

From my perspective, unique_ptr is the right thing if each method/callback takes
the queue, possibly mutates it, then passes it along to the next. Ownership is
clear, and there's less churn in the heap.

[macourteau, 2016/09/12 19:53:14]

Done.

+
+      // 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)) {
+        re2::RE2 args_pattern("args(\\d+)");

[csharp, 2016/08/11 18:58:02]

What about pulling this args and suffix creation code into a helper function
that can be tested?

[Joe Mason, 2016/08/15 17:24:39]

Done.

+        std::map<int, std::string> arg_strings;
+
+        re2::RE2 suffix_pattern("suffix(\\d+)");
+        std::map<int, std::string> suffixes;
+
+        unsigned int max_index = 0;

[grt (UTC plus 2), 2016/08/10 06:47:01]

"unsigned int" is frowned upon
(https://google.github.io/styleguide/cppguide.html#Integer_Types; "In
particular, do not use unsigned types to say a number will never be negative.").
is "int" combined with relevant range checking adequate here?

[Joe Mason, 2016/08/15 17:24:39]

Done.

+        for (const auto& param : experiment_params) {

[grt (UTC plus 2), 2016/08/10 06:47:01]

nit: param -> param_and_value or something like that so that it's more clear
that ".first" is the param and ".second" is its value.

[Joe Mason, 2016/08/15 17:24:39]

Done.

+          unsigned int index = 0;
+          if (re2::RE2::FullMatch(param.first, args_pattern, &index)) {
+            arg_strings[index] = param.second;
+            max_index = std::max(index, max_index);

[csharp, 2016/08/11 18:58:02]

nit: What about moving this line outside the if statement here, since it is the
same for both cases (and if both cases fail index=0, so it wouldn't change
anything)

[Joe Mason, 2016/08/15 17:24:39]

Done.

+          } else if (re2::RE2::FullMatch(param.first, suffix_pattern, &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;

[csharp, 2016/08/11 18:58:02]

Shouldn't this return here, it seems a bit odd to at line 223 run the reporter
without any parameters, instead of not running.

[Joe Mason, 2016/08/15 17:24:39]

As we discussed, it now doesn't run the reporter at all on error. The logic
changed in a couple of places for that, not just here.

+          }
+
+          // Construct the command-line using a placeholder which is guaranteed
+          // not to need quoting for arg 0. Then replace it with the real path,

[grt (UTC plus 2), 2016/08/10 06:47:01]

why jump through these hoops? Does CommandLine not do the right thing if you
initialize it with exe_path and then append the args?

[Joe Mason, 2016/08/15 17:24:39]

CommandLine doesn't have any method to append a string of args unless it's
already parsed. Updated the comment to better explain this.

+          // which may contain spaces and other weirdness.
+          auto command_line = base::CommandLine::FromString(base::UTF8ToUTF16(
+                base::StringPrintf("%s %s", kSwReporterExeName, args->second)));

[grt (UTC plus 2), 2016/08/10 06:47:01]

kSwReporterExeName is a wide char literal on Windows. can you guarantee that the
args are ASCII? maybe you're better off with: L"%ls %ls", kSwReporterExeName,
base::ASCIIToUTF16(args->second)

[Joe Mason, 2016/08/15 17:24:39]

Done.

+          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));

[grt (UTC plus 2), 2016/08/10 06:47:01]

can you guarantee that the suffixes are ASCII? if so, use AppendSwitchASCII

[Joe Mason, 2016/08/15 17:24:39]

Done.

+
+          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.
+      static const char kTagParam[] = "tag";

[grt (UTC plus 2), 2016/08/10 06:47:01]

static const -> constexpr

[Joe Mason, 2016/08/15 17:24:39]

Done.

+      std::string tag = variations::GetVariationParamValueByFeature(
+          kExperimentalEngineFeature, kTagParam);
+      if (!tag.empty())
+        attributes[kTagParam] = 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