Update SplitString calls in components

components/translate/core/language_detection/language_detection_util.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/translate/core/language_detection/language_detection_util.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 294 matching lines @@
     *code = base::StringToLowerASCII(code->substr(0, dash_index)) +
         base::StringToUpperASCII(code->substr(dash_index));
   } else {
     *code = base::StringToLowerASCII(*code);
   }
 }
 
 bool IsValidLanguageCode(const std::string& code) {
   // Roughly check if the language code follows /[a-zA-Z]{2,3}(-[a-zA-Z]{2})?/.
   // TODO(hajimehoshi): How about es-419, which is used as an Accept language?
-  std::vector<std::string> chunks;
-  base::SplitString(code, '-', &chunks);
+  std::vector<base::StringPiece> chunks = base::SplitStringPiece(
+      code, "-", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (chunks.size() < 1 || 2 < chunks.size())
     return false;
 
-  const std::string& main_code = chunks[0];
+  const base::StringPiece& main_code = chunks[0];
 
   if (main_code.size() < 1 || 3 < main_code.size())
     return false;
 
-  for (std::string::const_iterator it = main_code.begin();
-       it != main_code.end(); ++it) {
-    if (!base::IsAsciiAlpha(*it))
+  for (char c : main_code) {
+    if (!base::IsAsciiAlpha(c))
       return false;
   }
 
   if (chunks.size() == 1)
     return true;
 
-  const std::string& sub_code = chunks[1];
+  const base::StringPiece& sub_code = chunks[1];
 
   if (sub_code.size() != 2)
     return false;
 
-  for (std::string::const_iterator it = sub_code.begin();
-       it != sub_code.end(); ++it) {
-    if (!base::IsAsciiAlpha(*it))
+  for (char c : sub_code) {
+    if (!base::IsAsciiAlpha(c))
       return false;
   }
 
   return true;
 }
 
 bool IsSameOrSimilarLanguages(const std::string& page_language,
                               const std::string& cld_language) {
-  std::vector<std::string> chunks;
-
-  base::SplitString(page_language, '-', &chunks);
+  std::vector<std::string> chunks = base::SplitString(
+      page_language, "-", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   if (chunks.size() == 0)
     return false;
-  std::string page_language_main_part = chunks[0];
+  std::string page_language_main_part = chunks[0];  // Need copy.
 
-  base::SplitString(cld_language, '-', &chunks);
+  chunks = base::SplitString(
+      cld_language, "-", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   if (chunks.size() == 0)
     return false;
-  std::string cld_language_main_part = chunks[0];
+  const std::string& cld_language_main_part = chunks[0];
 
   // Language code part of |page_language| is matched to one of |cld_language|.
   // Country code is ignored here.
   if (page_language_main_part == cld_language_main_part) {
     // Languages are matched strictly. Reports false to metrics, but returns
     // true.
     translate::ReportSimilarLanguageMatch(false);
     return true;
   }
 
@@ skipping 20 matching lines @@
   // distinguish from English, and the language is one of well-known languages
   // which often provide "en-*" meta information mistakenly.
   for (size_t i = 0; i < arraysize(kWellKnownCodesOnWrongConfiguration); ++i) {
     if (cld_language == kWellKnownCodesOnWrongConfiguration[i])
       return true;
   }
   return false;
 }
 
 }  // namespace translate