Update SplitString calls in components

components/variations/study_filtering_unittest.cc

 // Copyright 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 "components/variations/study_filtering.h"
 
 #include <vector>
 
 #include "base/strings/string_split.h"
 #include "components/variations/processed_study.h"
@@ skipping 121 matching lines @@
     {"en-US", true, false, false},
     {"en-US,en-CA,fr", true, true, true},
     {"en-US,en-CA,en-GB", true, true, false},
     {"en-GB,en-CA,en-US", true, true, false},
     {"ja,kr,vi", false, false, false},
     {"fr-CA", false, false, false},
     {"", true, true, true},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    std::vector<std::string> filter_locales;
     Study_Filter filter;
-    base::SplitString(test_cases[i].filter_locales, ',', &filter_locales);
-    for (size_t j = 0; j < filter_locales.size(); ++j)
-      filter.add_locale(filter_locales[j]);
+    for (const std::string& locale : base::SplitString(
+             test_cases[i].filter_locales, ",",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
+      filter.add_locale(locale);
     EXPECT_EQ(test_cases[i].en_us_result,
               internal::CheckStudyLocale(filter, "en-US"));
     EXPECT_EQ(test_cases[i].en_ca_result,
               internal::CheckStudyLocale(filter, "en-CA"));
     EXPECT_EQ(test_cases[i].fr_result,
               internal::CheckStudyLocale(filter, "fr"));
   }
 }
 
 TEST(VariationsStudyFilteringTest, CheckStudyPlatform) {
@@ skipping 191 matching lines @@
     {"", "apple,pear,orange", "fancy INTEL SNapple device", false},
     // Empty.
     {"", "apple,pear,orange", "", true},
 
     // Not testing when both are set as it should never occur and should be
     // considered undefined.
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     Study_Filter filter;
-    std::vector<std::string> hardware_class;
-    base::SplitString(test_cases[i].hardware_class, ',', &hardware_class);
-    for (size_t j = 0; j < hardware_class.size(); ++j)
-      filter.add_hardware_class(hardware_class[j]);
+    for (const std::string& cur : base::SplitString(
+             test_cases[i].hardware_class, ",",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
+      filter.add_hardware_class(cur);
 
-    std::vector<std::string> exclude_hardware_class;
-    base::SplitString(test_cases[i].exclude_hardware_class, ',',
-                      &exclude_hardware_class);
-    for (size_t j = 0; j < exclude_hardware_class.size(); ++j)
-      filter.add_exclude_hardware_class(exclude_hardware_class[j]);
+    for (const std::string& cur : base::SplitString(
+             test_cases[i].exclude_hardware_class, ",",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
+      filter.add_exclude_hardware_class(cur);
 
     EXPECT_EQ(test_cases[i].expected_result,
               internal::CheckStudyHardwareClass(
                   filter, test_cases[i].actual_hardware_class));
   }
 }
 
 TEST(VariationsStudyFilteringTest, CheckStudyCountry) {
   struct {
     const char* country;
@@ skipping 21 matching lines @@
       // Empty, which is what would happen if no country was returned from the
       // server.
       {"", "br,ca,us", "", true},
 
       // Not testing when both are set as it should never occur and should be
       // considered undefined.
   };
 
   for (const auto& test : test_cases) {
     Study_Filter filter;
-    std::vector<std::string> countries;
-    base::SplitString(test.country, ',', &countries);
-    for (const std::string& country : countries)
+    for (const std::string& country : base::SplitString(
+             test.country, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_country(country);
 
-    std::vector<std::string> exclude_countries;
-    base::SplitString(test.exclude_country, ',', &exclude_countries);
-    for (const std::string& exclude_country : exclude_countries)
+    for (const std::string& exclude_country : base::SplitString(
+             test.exclude_country, ",",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_exclude_country(exclude_country);
 
     EXPECT_EQ(test.expected_result,
               internal::CheckStudyCountry(filter, test.actual_country));
   }
 }
 
 TEST(VariationsStudyFilteringTest, FilterAndValidateStudies) {
   const std::string kTrial1Name = "A";
   const std::string kGroup1Name = "Group1";
@@ skipping 144 matching lines @@
 
   default_group->set_name("def");
   EXPECT_TRUE(processed_study.Init(&study, false));
   Study_Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   EXPECT_FALSE(processed_study.Init(&study, false));
 }
 
 }  // namespace variations