Add support for multiple simultaneous subresource_filter::Configurations.

chrome/browser/component_updater/subresource_filter_component_installer_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/subresource_filter_component_installer.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/version.h"
@@ skipping 58 matching lines @@
 
   scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner() override {
     return base::ThreadTaskRunnerHandle::Get();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SubresourceFilterMockComponentUpdateService);
 };
 
 subresource_filter::Configuration CreateConfigUsingRulesetFlavor(
-    const char* ruleset_flavor) {
+    std::string ruleset_flavor) {

[Sorin Jianu, 2017/05/09 01:49:08]

can we pass by ref to const and avoid the move below?

[engedy, 2017/05/09 11:39:35]

Done.

   subresource_filter::Configuration config;
-  config.ruleset_flavor = ruleset_flavor;
+  config.general_settings.ruleset_flavor = std::move(ruleset_flavor);
   return config;
 }
 
 }  //  namespace
 
 namespace component_updater {
 
 class SubresourceFilterComponentInstallerTest : public PlatformTest {
  public:
   SubresourceFilterComponentInstallerTest() {}
@@ skipping 62 matching lines @@
     const base::Version expected_version(kTestRulesetVersion);
     traits_->ComponentReady(expected_version, component_install_dir(),
                             std::move(manifest));
     base::RunLoop().RunUntilIdle();
   }
 
   update_client::InstallerAttributes GetInstallerAttributes() {
     return traits_->GetInstallerAttributes();
   }
 
-  void ExpectInstallerTag(const char* expected_tag,
-                          const char* ruleset_flavor) {
-    subresource_filter::testing::ScopedSubresourceFilterConfigurator
-        scoped_configuration(CreateConfigUsingRulesetFlavor(ruleset_flavor));
-    EXPECT_EQ(expected_tag,
-              SubresourceFilterComponentInstallerTraits::GetInstallerTag());
-  }
-
  private:
   base::ScopedTempDir component_install_dir_;
   base::ScopedTempDir ruleset_service_dir_;
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<SubresourceFilterComponentInstallerTraits> traits_;
   TestingPrefServiceSimple pref_service_;
 
   TestRulesetService* test_ruleset_service_ = nullptr;
 
@@ skipping 63 matching lines @@
   std::string actual_license_contents;
   ASSERT_TRUE(base::ReadFileToString(service()->ruleset_path(),
                                      &actual_ruleset_contents));
   EXPECT_EQ(expected_ruleset_contents, actual_ruleset_contents);
   ASSERT_TRUE(base::ReadFileToString(service()->license_path(),
                                      &actual_license_contents));
   EXPECT_EQ(expected_license_contents, actual_license_contents);
 }
 
 TEST_F(SubresourceFilterComponentInstallerTest, InstallerTag) {
-  ExpectInstallerTag("", "");
-  ExpectInstallerTag("a", "a");
-  ExpectInstallerTag("b", "b");
-  ExpectInstallerTag("c", "c");
-  ExpectInstallerTag("d", "d");
-  ExpectInstallerTag("invalid", "e");
-  ExpectInstallerTag("invalid", "foo");
+  const struct {
+    const char* expected_installer_tag_selected;
+    std::vector<std::string> ruleset_flavors;
+  } kTestCases[] = {{"", std::vector<std::string>()},
+                    {"", {""}},
+                    {"a", {"a"}},
+                    {"b", {"b"}},
+                    {"c", {"c"}},
+                    {"d", {"d"}},
+                    {"invalid", {"e"}},
+                    {"invalid", {"foo"}},
+                    {"", {"", ""}},
+                    {"a", {"a", ""}},
+                    {"a", {"", "a"}},
+                    {"a", {"a", "a"}},
+                    {"c", {"b", "", "c"}},
+                    {"b", {"", "b", "a"}},
+                    {"c", {"aaa", "c", "aba"}},
+                    {"invalid", {"", "a", "e"}},
+                    {"invalid", {"foo", "a", "b"}}};
+
+  for (const auto& test_case : kTestCases) {
+    SCOPED_TRACE(::testing::Message()
+                 << "ruleset_flavors: "
+                 << ::testing::PrintToString(test_case.ruleset_flavors));
+
+    std::vector<subresource_filter::Configuration> configs;
+    for (const auto& ruleset_flavor : test_case.ruleset_flavors)
+      configs.push_back(CreateConfigUsingRulesetFlavor(ruleset_flavor));
+    subresource_filter::testing::ScopedSubresourceFilterConfigurator
+        scoped_configuration(std::move(configs));
+
+    EXPECT_EQ(test_case.expected_installer_tag_selected,
+              SubresourceFilterComponentInstallerTraits::GetInstallerTag());
+  }
 }
 
 TEST_F(SubresourceFilterComponentInstallerTest, InstallerAttributesDefault) {
   subresource_filter::testing::ScopedSubresourceFilterConfigurator
       scoped_configuration((subresource_filter::Configuration()));
   EXPECT_EQ(update_client::InstallerAttributes(), GetInstallerAttributes());
 }
 
 TEST_F(SubresourceFilterComponentInstallerTest, InstallerAttributesCustomTag) {
   constexpr char kTagKey[] = "tag";
   constexpr char kTagValue[] = "a";
 
   subresource_filter::testing::ScopedSubresourceFilterConfigurator
       scoped_configuration(CreateConfigUsingRulesetFlavor(kTagValue));
   EXPECT_EQ(update_client::InstallerAttributes({{kTagKey, kTagValue}}),
             GetInstallerAttributes());
 }
 
 }  // namespace component_updater