Add support for the ExperimentalSwReporterEngine field trial.

chrome/browser/component_updater/sw_reporter_installer_win_unittest.cc

 // Copyright 2016 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 <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 19 matching lines @@
 
 namespace component_updater {
 
 namespace {
 
 constexpr char kRegistrySuffixSwitch[] = "registry-suffix";
 constexpr char kErrorHistogramName[] = "SoftwareReporter.ExperimentErrors";
 constexpr char kExperimentTag[] = "experiment_tag";
 constexpr char kMissingTag[] = "missing_tag";
 
+using safe_browsing::SwReporterInvocation;
+
 }  // namespace
 
 class SwReporterInstallerTest : public ::testing::Test {
  public:
   SwReporterInstallerTest()
       : launched_callback_(
             base::Bind(&SwReporterInstallerTest::SwReporterLaunched,
                        base::Unretained(this))),
         default_version_("1.2.3"),
-        default_path_(L"C:\\full\\path\\to\\download") {}
+        default_path_(L"C:\\full\\path\\to\\download"),
+        launched_version_("0.0.0") {}
 
   ~SwReporterInstallerTest() override {}
 
  protected:
-  void SwReporterLaunched(const safe_browsing::SwReporterInvocation& invocation,
+  void SwReporterLaunched(const safe_browsing::SwReporterQueue& invocations,
                           const base::Version& version) {
     ASSERT_TRUE(launched_invocations_.empty());
-    launched_invocations_.push_back(invocation);
+    auto mutable_invocations = invocations;

[Sorin Jianu, 2016/09/01 15:59:09]

Can we use an algorithm to filter out items instead of coding a loop?

[Joe Mason, 2016/09/02 02:24:30]

You can't use an algorithm on std::queue because it doesn't supply iterators.
But there's no reason to use a vector for launched_invocations_ anyway - I
thought random access would be useful for tests, but it turned out not to be. So
I just made launched_invocations_ a queue as well so I can assign them directly.

+    while (!mutable_invocations.empty()) {
+      launched_invocations_.push_back(mutable_invocations.front());
+      mutable_invocations.pop();
+    }
     launched_version_ = version;
   }
 
   base::FilePath MakeTestFilePath(const base::FilePath& path) const {
     return path.Append(L"software_reporter_tool.exe");
   }
 
   void ExpectEmptyAttributes(const SwReporterInstallerTraits& traits) const {
     update_client::InstallerAttributes attributes =
         traits.GetInstallerAttributes();
     EXPECT_TRUE(attributes.empty());
   }
 
   // Expects that the SwReporter was launched exactly once, with no arguments.
   void ExpectDefaultInvocation() const {
     EXPECT_EQ(default_version_, launched_version_);
     ASSERT_EQ(1U, launched_invocations_.size());
 
-    const safe_browsing::SwReporterInvocation& invocation =
-        launched_invocations_[0];
+    const SwReporterInvocation& invocation = launched_invocations_[0];
     EXPECT_EQ(MakeTestFilePath(default_path_),
               invocation.command_line.GetProgram());
     EXPECT_TRUE(invocation.command_line.GetSwitches().empty());
     EXPECT_TRUE(invocation.command_line.GetArgs().empty());
     EXPECT_TRUE(invocation.suffix.empty());
-    EXPECT_FALSE(invocation.is_experimental);
+    EXPECT_EQ(SwReporterInvocation::FLAG_LOG_TO_RAPPOR |
+                  SwReporterInvocation::FLAG_LOG_TO_PREFS |
+                  SwReporterInvocation::FLAG_TRIGGER_PROMPT,
+              invocation.flags);
   }
 
   // |ComponentReady| asserts that it is run on the UI thread, so we must
   // create test threads before calling it.
   content::TestBrowserThreadBundle threads_;
 
   // Bound callback to the |SwReporterLaunched| method.
   SwReporterRunner launched_callback_;
 
   // Default parameters for |ComponentReady|.
   base::Version default_version_;
   base::FilePath default_path_;
 
   // Results of running |ComponentReady|.
-  std::vector<safe_browsing::SwReporterInvocation> launched_invocations_;
+  std::vector<SwReporterInvocation> launched_invocations_;
   base::Version launched_version_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SwReporterInstallerTest);
 };
 
 // This class contains extended setup that is only used for tests of the
 // experimental reporter.
 class ExperimentalSwReporterInstallerTest : public SwReporterInstallerTest {
  public:
@@ skipping 45 matching lines @@
   // |expected_suffix| and one |expected_additional_argument| on the
   // command-line. (|expected_additional_argument| mainly exists to test that
   // arguments are included at all, so there is no need to test for
   // combinations of multiple arguments and switches in this function.)
   void ExpectExperimentalInvocation(
       const std::string& expected_suffix,
       const base::string16& expected_additional_argument) {
     EXPECT_EQ(default_version_, launched_version_);
     ASSERT_EQ(1U, launched_invocations_.size());
 
-    const safe_browsing::SwReporterInvocation& invocation =
-        launched_invocations_[0];
+    const SwReporterInvocation& invocation = launched_invocations_[0];
     EXPECT_EQ(MakeTestFilePath(default_path_),
               invocation.command_line.GetProgram());
 
     if (expected_suffix.empty()) {
       EXPECT_TRUE(invocation.command_line.GetSwitches().empty());
       EXPECT_TRUE(invocation.suffix.empty());
     } else {
       EXPECT_EQ(1U, invocation.command_line.GetSwitches().size());
       EXPECT_EQ(expected_suffix, invocation.command_line.GetSwitchValueASCII(
                                      kRegistrySuffixSwitch));
       EXPECT_EQ(expected_suffix, invocation.suffix);
     }
 
     if (expected_additional_argument.empty()) {
       EXPECT_TRUE(invocation.command_line.GetArgs().empty());
     } else {
       EXPECT_EQ(1U, invocation.command_line.GetArgs().size());
       EXPECT_EQ(expected_additional_argument,
                 invocation.command_line.GetArgs()[0]);
     }
 
-    EXPECT_TRUE(invocation.is_experimental);
+    EXPECT_EQ(0, invocation.flags);
     histograms_.ExpectTotalCount(kErrorHistogramName, 0);
   }
 
   void ExpectLaunchError() {
     // The SwReporter should not be launched, and an error should be logged.
     EXPECT_TRUE(launched_invocations_.empty());
     histograms_.ExpectUniqueSample(kErrorHistogramName,
                                    SW_REPORTER_EXPERIMENT_ERROR_BAD_PARAMS, 1);
   }
 
@@ skipping 69 matching lines @@
 
 TEST_F(ExperimentalSwReporterInstallerTest, SingleInvocation) {
   SwReporterInstallerTraits traits(launched_callback_, true);
   CreateFeatureWithTag(kExperimentTag);
   ExpectAttributesWithTag(traits, kExperimentTag);
 
   static constexpr char kTestManifest[] =
       "{\"launch_params\": ["
       "  {"
       "    \"arguments\": [\"--engine=experimental\", \"random argument\"],"
-      "    \"suffix\": \"TestSuffix\""
+      "    \"suffix\": \"TestSuffix\","
+      "    \"prompt\": false"
       "  }"
       "]}";
   traits.ComponentReady(
       default_version_, default_path_,
       base::DictionaryValue::From(base::JSONReader::Read(kTestManifest)));
 
   // The SwReporter should be launched once with the given arguments.
   EXPECT_EQ(default_version_, launched_version_);
   ASSERT_EQ(1U, launched_invocations_.size());
 
-  const safe_browsing::SwReporterInvocation& invocation =
-      launched_invocations_[0];
+  const SwReporterInvocation& invocation = launched_invocations_[0];
   EXPECT_EQ(MakeTestFilePath(default_path_),
             invocation.command_line.GetProgram());
   EXPECT_EQ(2U, invocation.command_line.GetSwitches().size());
   EXPECT_EQ("experimental",
             invocation.command_line.GetSwitchValueASCII("engine"));
   EXPECT_EQ("TestSuffix",
             invocation.command_line.GetSwitchValueASCII(kRegistrySuffixSwitch));
   ASSERT_EQ(1U, invocation.command_line.GetArgs().size());
   EXPECT_EQ(L"random argument", invocation.command_line.GetArgs()[0]);
   EXPECT_EQ("TestSuffix", invocation.suffix);
-  EXPECT_TRUE(invocation.is_experimental);
+  EXPECT_EQ(0, invocation.flags);
   histograms_.ExpectTotalCount(kErrorHistogramName, 0);
 }
 
 TEST_F(ExperimentalSwReporterInstallerTest, MultipleInvocations) {
   SwReporterInstallerTraits traits(launched_callback_, true);
   CreateFeatureWithTag(kExperimentTag);
   ExpectAttributesWithTag(traits, kExperimentTag);
 
   static constexpr char kTestManifest[] =
       "{\"launch_params\": ["
       "  {"
       "    \"arguments\": [\"--engine=experimental\", \"random argument\"],"
-      "    \"suffix\": \"TestSuffix\""
+      "    \"suffix\": \"TestSuffix\","
+      "    \"prompt\": false"
       "  },"
       "  {"
       "    \"arguments\": [\"--engine=second\"],"
-      "    \"suffix\": \"SecondSuffix\""
+      "    \"suffix\": \"SecondSuffix\","
+      "    \"prompt\": true"
+      "  },"
+      "  {"
+      "    \"arguments\": [\"--engine=third\"],"
+      "    \"suffix\": \"ThirdSuffix\""
       "  }"
       "]}";
   traits.ComponentReady(
       default_version_, default_path_,
       base::DictionaryValue::From(base::JSONReader::Read(kTestManifest)));
 
-  // Not supported yet.
-  ExpectLaunchError();
+  // The SwReporter should be launched three times with the given arguments.
+  EXPECT_EQ(default_version_, launched_version_);
+  ASSERT_EQ(3U, launched_invocations_.size());
+
+  {
+    const SwReporterInvocation& invocation = launched_invocations_[0];
+    EXPECT_EQ(MakeTestFilePath(default_path_),
+              invocation.command_line.GetProgram());
+    EXPECT_EQ(2U, invocation.command_line.GetSwitches().size());
+    EXPECT_EQ("experimental",
+              invocation.command_line.GetSwitchValueASCII("engine"));
+    EXPECT_EQ("TestSuffix", invocation.command_line.GetSwitchValueASCII(
+                                kRegistrySuffixSwitch));
+    ASSERT_EQ(1U, invocation.command_line.GetArgs().size());
+    EXPECT_EQ(L"random argument", invocation.command_line.GetArgs()[0]);
+    EXPECT_EQ("TestSuffix", invocation.suffix);
+    EXPECT_EQ(0, invocation.flags);
+  }
+
+  {
+    const SwReporterInvocation& invocation = launched_invocations_[1];
+    EXPECT_EQ(MakeTestFilePath(default_path_),
+              invocation.command_line.GetProgram());
+    EXPECT_EQ(2U, invocation.command_line.GetSwitches().size());
+    EXPECT_EQ("second", invocation.command_line.GetSwitchValueASCII("engine"));
+    EXPECT_EQ("SecondSuffix", invocation.command_line.GetSwitchValueASCII(
+                                  kRegistrySuffixSwitch));
+    ASSERT_TRUE(invocation.command_line.GetArgs().empty());
+    EXPECT_EQ("SecondSuffix", invocation.suffix);
+    EXPECT_EQ(SwReporterInvocation::FLAG_TRIGGER_PROMPT, invocation.flags);
+  }
+
+  {
+    const SwReporterInvocation& invocation = launched_invocations_[2];
+    EXPECT_EQ(MakeTestFilePath(default_path_),
+              invocation.command_line.GetProgram());
+    EXPECT_EQ(2U, invocation.command_line.GetSwitches().size());
+    EXPECT_EQ("third", invocation.command_line.GetSwitchValueASCII("engine"));
+    EXPECT_EQ("ThirdSuffix", invocation.command_line.GetSwitchValueASCII(
+                                 kRegistrySuffixSwitch));
+    ASSERT_TRUE(invocation.command_line.GetArgs().empty());
+    EXPECT_EQ("ThirdSuffix", invocation.suffix);
+    // A missing "prompt" key means "false".
+    EXPECT_EQ(0, invocation.flags);
+  }
+
+  histograms_.ExpectTotalCount(kErrorHistogramName, 0);
 }
 
 TEST_F(ExperimentalSwReporterInstallerTest, MissingSuffix) {
   SwReporterInstallerTraits traits(launched_callback_, true);
   CreateFeatureWithTag(kExperimentTag);
 
   static constexpr char kTestManifest[] =
       "{\"launch_params\": ["
       "  {"
       "    \"arguments\": [\"random argument\"]"
@@ skipping 280 matching lines @@
   traits.ComponentReady(
       default_version_, default_path_,
       base::DictionaryValue::From(base::JSONReader::Read(kTestManifest)));
 
   // The SwReporter should not be launched, and an error should be logged.
   EXPECT_TRUE(launched_invocations_.empty());
   histograms_.ExpectUniqueSample(kErrorHistogramName,
                                  SW_REPORTER_EXPERIMENT_ERROR_BAD_PARAMS, 1);
 }
 
+TEST_F(ExperimentalSwReporterInstallerTest, BadTypesInManifest4) {
+  SwReporterInstallerTraits traits(launched_callback_, true);
+  CreateFeatureWithTag(kExperimentTag);
+
+  // This has an int instead of a bool for prompt.
+  static constexpr char kTestManifest[] =
+      "{\"launch_params\": ["
+      "  {"
+      "    \"arguments\": [\"--engine=experimental\"],"
+      "    \"suffix\": \"TestSuffix\","
+      "    \"prompt\": 1"
+      "  }"
+      "]}";
+  traits.ComponentReady(
+      default_version_, default_path_,
+      base::DictionaryValue::From(base::JSONReader::Read(kTestManifest)));
+
+  // The SwReporter should not be launched, and an error should be logged.
+  EXPECT_TRUE(launched_invocations_.empty());
+  histograms_.ExpectUniqueSample(kErrorHistogramName,
+                                 SW_REPORTER_EXPERIMENT_ERROR_BAD_PARAMS, 1);
+}
 }  // namespace component_updater