Update SplitString calls in components

components/bookmarks/browser/bookmark_index_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/bookmarks/browser/bookmark_index.h"
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 91 matching lines @@
           found = true;
           break;
         }
       }
       ASSERT_TRUE(found);
     }
   }
 
   void ExtractMatchPositions(const std::string& string,
                              BookmarkMatch::MatchPositions* matches) {
-    std::vector<std::string> match_strings;
-    base::SplitString(string, ':', &match_strings);
-    for (size_t i = 0; i < match_strings.size(); ++i) {
-      std::vector<std::string> chunks;
-      base::SplitString(match_strings[i], ',', &chunks);
+    for (const base::StringPiece& match :
+         base::SplitStringPiece(string, ":",
+                                base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      std::vector<base::StringPiece> chunks = base::SplitStringPiece(
+          match, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       ASSERT_EQ(2U, chunks.size());
       matches->push_back(BookmarkMatch::MatchPosition());
       int chunks0, chunks1;
       EXPECT_TRUE(base::StringToInt(chunks[0], &chunks0));
       EXPECT_TRUE(base::StringToInt(chunks[1], &chunks1));
       matches->back().first = chunks0;
       matches->back().second = chunks1;
     }
   }
 
@@ skipping 58 matching lines @@
       "abc def abc def abc def abc def abc def",
       "abc1 abc2 abc3 abc4 def1 def2 def3 def4"},
 
     // Prefix match on the first term.
     { "abc",                        "a",        "" },
 
     // Prefix match on subsequent terms.
     { "abc def",                    "abc d",    "" },
   };
   for (size_t i = 0; i < arraysize(data); ++i) {
-    std::vector<std::string> titles;
-    base::SplitString(data[i].titles, ';', &titles);
     std::vector<TitleAndURL> bookmarks;
-    for (size_t j = 0; j < titles.size(); ++j) {
-      TitleAndURL bookmark(titles[j], kAboutBlankURL);
+    for (const std::string& title : base::SplitString(
+             data[i].titles, ";",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      TitleAndURL bookmark(title, kAboutBlankURL);
       bookmarks.push_back(bookmark);
     }
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
-    if (!data[i].expected.empty())
-      base::SplitString(data[i].expected, ';', &expected);
+    if (!data[i].expected.empty()) {
+      expected = base::SplitString(data[i].expected, ";",
+                                   base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    }
 
     ExpectMatches(data[i].query, query_parser::MatchingAlgorithm::DEFAULT,
                   expected);
 
     model_ = client_.CreateModel();
   }
 }
 
 TEST_F(BookmarkIndexTest, GetBookmarksMatchingAlwaysPrefixSearch) {
   struct TestData {
@@ skipping 27 matching lines @@
     // Prefix match on the first term.
     { "abc",                        "a",        "abc" },
 
     // Prefix match on subsequent terms.
     { "abc def",                    "abc d",    "abc def" },
 
     // Exact and prefix match.
     { "ab cdef;abcd;abcd cdefg",    "ab cdef",  "ab cdef;abcd cdefg" },
   };
   for (size_t i = 0; i < arraysize(data); ++i) {
-    std::vector<std::string> titles;
-    base::SplitString(data[i].titles, ';', &titles);
     std::vector<TitleAndURL> bookmarks;
-    for (size_t j = 0; j < titles.size(); ++j) {
-      TitleAndURL bookmark(titles[j], kAboutBlankURL);
+    for (const std::string& title : base::SplitString(
+             data[i].titles, ";",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      TitleAndURL bookmark(title, kAboutBlankURL);
       bookmarks.push_back(bookmark);
     }
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
-    if (!data[i].expected.empty())
-      base::SplitString(data[i].expected, ';', &expected);
+    if (!data[i].expected.empty()) {
+      expected = base::SplitString(data[i].expected, ";",
+                                   base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    }
 
     ExpectMatches(data[i].query,
                   query_parser::MatchingAlgorithm::ALWAYS_PREFIX_SEARCH,
                   expected);
 
     model_ = client_.CreateModel();
   }
 }
 
 // Analogous to GetBookmarksMatching, this test tests various permutations
@@ skipping 272 matching lines @@
   // Select top two matches.
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 2, &matches);
 
   ASSERT_EQ(2U, matches.size());
   EXPECT_EQ(data[0].url, matches[0].node->url());
   EXPECT_EQ(data[3].url, matches[1].node->url());
 }
 
 }  // namespace
 }  // namespace bookmarks