Fix GCC build for target 'all'

components/certificate_transparency/ct_policy_manager_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 "components/certificate_transparency/ct_policy_manager.h"
 
 #include <iterator>
 
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_message_loop.h"
 #include "base/values.h"
 #include "components/certificate_transparency/pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/testing_pref_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace certificate_transparency {
 
 namespace {
 
-template <size_t N>
-base::ListValue* ListValueFromStrings(const char* const (&strings)[N]) {
+base::ListValue* ListValueFromStrings(const std::vector<const char*>& strings) {
   std::unique_ptr<base::ListValue> result(new base::ListValue);
-  for (const auto& str : strings) {
+  for (auto* const str : strings) {
     result->AppendString(str);
   }
   return result.release();
 }
 
 class CTPolicyManagerTest : public ::testing::Test {
  public:
   CTPolicyManagerTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
 
  protected:
@@ skipping 23 matching lines @@
   net::TransportSecurityState::RequireCTDelegate* delegate =
       manager.GetDelegate();
   ASSERT_TRUE(delegate);
 
   // No preferences should yield the default results.
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("google.com"));
 
   // Now set a preference, pump the message loop, and ensure things are now
   // reflected.
-  pref_service_.SetManagedPref(prefs::kCTRequiredHosts,
-                               ListValueFromStrings({"google.com"}));
+  pref_service_.SetManagedPref(
+      prefs::kCTRequiredHosts,
+      ListValueFromStrings(std::vector<const char*>{"google.com"}));
   base::RunLoop().RunUntilIdle();
 
   // The new preferences should take effect.
   EXPECT_EQ(CTRequirementLevel::REQUIRED,
             delegate->IsCTRequiredForHost("google.com"));
 }
 
 TEST_F(CTPolicyManagerTest, DelegateChecksExcluded) {
   using CTRequirementLevel =
       net::TransportSecurityState::RequireCTDelegate::CTRequirementLevel;
   // Register preferences and set up initial state
   CTPolicyManager::RegisterPrefs(pref_service_.registry());
   CTPolicyManager manager(&pref_service_, message_loop_.task_runner());
   base::RunLoop().RunUntilIdle();
 
   net::TransportSecurityState::RequireCTDelegate* delegate =
       manager.GetDelegate();
   ASSERT_TRUE(delegate);
 
   // No preferences should yield the default results.
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("google.com"));
 
   // Now set a preference, pump the message loop, and ensure things are now
   // reflected.
-  pref_service_.SetManagedPref(prefs::kCTExcludedHosts,
-                               ListValueFromStrings({"google.com"}));
+  pref_service_.SetManagedPref(
+      prefs::kCTExcludedHosts,
+      ListValueFromStrings(std::vector<const char*>{"google.com"}));
   base::RunLoop().RunUntilIdle();
 
   // The new preferences should take effect.
   EXPECT_EQ(CTRequirementLevel::NOT_REQUIRED,
             delegate->IsCTRequiredForHost("google.com"));
 }
 
 TEST_F(CTPolicyManagerTest, IgnoresInvalidEntries) {
   using CTRequirementLevel =
       net::TransportSecurityState::RequireCTDelegate::CTRequirementLevel;
   // Register preferences and set up initial state
   CTPolicyManager::RegisterPrefs(pref_service_.registry());
   CTPolicyManager manager(&pref_service_, message_loop_.task_runner());
   base::RunLoop().RunUntilIdle();
 
   net::TransportSecurityState::RequireCTDelegate* delegate =
       manager.GetDelegate();
   ASSERT_TRUE(delegate);
 
   // No preferences should yield the default results.
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("google.com"));
 
   // Now setup invalid preferences (that is, that fail to be parsable as
   // URLs).
   pref_service_.SetManagedPref(
       prefs::kCTRequiredHosts,
-      ListValueFromStrings({
+      ListValueFromStrings(std::vector<const char*>{
           "file:///etc/fstab", "file://withahost/etc/fstab",
           "file:///c|/Windows", "*", "https://*", "example.com",
           "https://example.test:invalid_port",
       }));
   base::RunLoop().RunUntilIdle();
 
   // Wildcards are ignored (both * and https://*).
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("google.com"));
   // File URL hosts are ignored.
@@ skipping 36 matching lines @@
             delegate->IsCTRequiredForHost("sub.accounts.example.com"));
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("login.sub.accounts.example.com"));
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("test.example.com"));
 
   // Set up policies that exclude it for a domain and all of its subdomains,
   // but then require it for a specific host.
   pref_service_.SetManagedPref(
       prefs::kCTExcludedHosts,
-      ListValueFromStrings({"example.com", ".sub.example.com",
-                            ".sub.accounts.example.com", "test.example.com"}));
+      ListValueFromStrings(std::vector<const char*>{
+          "example.com", ".sub.example.com", ".sub.accounts.example.com",
+          "test.example.com"}));
   pref_service_.SetManagedPref(
       prefs::kCTRequiredHosts,
-      ListValueFromStrings(
-          {"sub.example.com", "accounts.example.com", "test.example.com"}));
+      ListValueFromStrings(std::vector<const char*>{
+          "sub.example.com", "accounts.example.com", "test.example.com"}));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(CTRequirementLevel::NOT_REQUIRED,
             delegate->IsCTRequiredForHost("example.com"));
   // Non-wildcarding (.sub.example.com) beats wildcarding (sub.example.com).
   EXPECT_EQ(CTRequirementLevel::NOT_REQUIRED,
             delegate->IsCTRequiredForHost("sub.example.com"));
   // More specific hosts (accounts.example.com) beat less specific hosts
   // (example.com + wildcard).
   EXPECT_EQ(CTRequirementLevel::REQUIRED,
@@ skipping 25 matching lines @@
   net::TransportSecurityState::RequireCTDelegate* delegate =
       manager.GetDelegate();
   ASSERT_TRUE(delegate);
 
   // No preferences should yield the default results.
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("google.com"));
 
   // Now set a preference, pump the message loop, and ensure things are now
   // reflected.
-  pref_service_.SetManagedPref(prefs::kCTRequiredHosts,
-                               ListValueFromStrings({"google.com"}));
+  pref_service_.SetManagedPref(
+      prefs::kCTRequiredHosts,
+      ListValueFromStrings(std::vector<const char*>{"google.com"}));
   base::RunLoop().RunUntilIdle();
 
   // The new preferences should take effect.
   EXPECT_EQ(CTRequirementLevel::REQUIRED,
             delegate->IsCTRequiredForHost("google.com"));
 
   // Shut down the preferences, which should unregister any observers.
   manager.Shutdown();
   base::RunLoop().RunUntilIdle();
 
   // Update the preferences again, which should do nothing; the
   // RequireCTDelegate should continue to be valid and return the old results.
   EXPECT_EQ(CTRequirementLevel::REQUIRED,
             delegate->IsCTRequiredForHost("google.com"));
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("example.com"));
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("sub.example.com"));
-  pref_service_.SetManagedPref(prefs::kCTRequiredHosts,
-                               ListValueFromStrings({"sub.example.com"}));
+  pref_service_.SetManagedPref(
+      prefs::kCTRequiredHosts,
+      ListValueFromStrings(std::vector<const char*>{"sub.example.com"}));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(CTRequirementLevel::REQUIRED,
             delegate->IsCTRequiredForHost("google.com"));
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("example.com"));
   EXPECT_EQ(CTRequirementLevel::DEFAULT,
             delegate->IsCTRequiredForHost("sub.example.com"));
 
   // And it should still be possible to get the delegate, even after calling
   // Shutdown().
   EXPECT_TRUE(manager.GetDelegate());
 }
 
 }  // namespace
 
 }  // namespace certificate_transparency