BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

1 files changed, 17 insertions, 128 deletions

diff --git a/chromium/base/strings/string_split.cc b/chromium/base/strings/string_split.cc
index a968e802e8c..4ba0412cc2c 100644
--- a/chromium/base/strings/string_split.cc
+++ b/chromium/base/strings/string_split.cc
@@ -7,6 +7,7 @@
 #include <stddef.h>
 
 #include "base/logging.h"
+#include "base/strings/string_split_internal.h"
 #include "base/strings/string_util.h"
 #include "base/third_party/icu/icu_utf.h"
 
@@ -14,56 +15,6 @@ namespace base {
 
 namespace {
 
-// Returns either the ASCII or UTF-16 whitespace.
-template<typename Str> BasicStringPiece<Str> WhitespaceForType();
-#if defined(OS_WIN) && defined(BASE_STRING16_IS_STD_U16STRING)
-template <>
-WStringPiece WhitespaceForType<std::wstring>() {
-  return kWhitespaceWide;
-}
-#endif
-
-template<> StringPiece16 WhitespaceForType<string16>() {
-  return kWhitespaceUTF16;
-}
-template<> StringPiece WhitespaceForType<std::string>() {
-  return kWhitespaceASCII;
-}
-
-// General string splitter template. Can take 8- or 16-bit input, can produce
-// the corresponding string or StringPiece output.
-template <typename OutputStringType, typename Str>
-static std::vector<OutputStringType> SplitStringT(
-    BasicStringPiece<Str> str,
-    BasicStringPiece<Str> delimiter,
-    WhitespaceHandling whitespace,
-    SplitResult result_type) {
-  std::vector<OutputStringType> result;
-  if (str.empty())
-    return result;
-
-  size_t start = 0;
-  while (start != Str::npos) {
-    size_t end = str.find_first_of(delimiter, start);
-
-    BasicStringPiece<Str> piece;
-    if (end == Str::npos) {
-      piece = str.substr(start);
-      start = Str::npos;
-    } else {
-      piece = str.substr(start, end - start);
-      start = end + 1;
-    }
-
-    if (whitespace == TRIM_WHITESPACE)
-      piece = TrimString(piece, WhitespaceForType<Str>(), TRIM_ALL);
-
-    if (result_type == SPLIT_WANT_ALL || !piece.empty())
-      result.emplace_back(piece);
-  }
-  return result;
-}
-
 bool AppendStringKeyValue(StringPiece input,
                           char delimiter,
                           StringPairs* result) {
@@ -94,67 +45,38 @@ bool AppendStringKeyValue(StringPiece input,
   return true;
 }
 
-template <typename OutputStringType, typename Str>
-std::vector<OutputStringType> SplitStringUsingSubstrT(
-    BasicStringPiece<Str> input,
-    BasicStringPiece<Str> delimiter,
-    WhitespaceHandling whitespace,
-    SplitResult result_type) {
-  using Piece = BasicStringPiece<Str>;
-  using size_type = typename Piece::size_type;
-
-  std::vector<OutputStringType> result;
-  if (delimiter.size() == 0) {
-    result.emplace_back(input);
-    return result;
-  }
-
-  for (size_type begin_index = 0, end_index = 0; end_index != Piece::npos;
-       begin_index = end_index + delimiter.size()) {
-    end_index = input.find(delimiter, begin_index);
-    Piece term = end_index == Piece::npos
-                     ? input.substr(begin_index)
-                     : input.substr(begin_index, end_index - begin_index);
-
-    if (whitespace == TRIM_WHITESPACE)
-      term = TrimString(term, WhitespaceForType<Str>(), TRIM_ALL);
-
-    if (result_type == SPLIT_WANT_ALL || !term.empty())
-      result.emplace_back(term);
-  }
-
-  return result;
-}
-
 }  // namespace
 
 std::vector<std::string> SplitString(StringPiece input,
                                      StringPiece separators,
                                      WhitespaceHandling whitespace,
                                      SplitResult result_type) {
-  return SplitStringT<std::string>(input, separators, whitespace, result_type);
+  return internal::SplitStringT<std::string>(input, separators, whitespace,
+                                             result_type);
 }
 
 std::vector<string16> SplitString(StringPiece16 input,
                                   StringPiece16 separators,
                                   WhitespaceHandling whitespace,
                                   SplitResult result_type) {
-  return SplitStringT<string16>(input, separators, whitespace, result_type);
+  return internal::SplitStringT<string16>(input, separators, whitespace,
+                                          result_type);
 }
 
 std::vector<StringPiece> SplitStringPiece(StringPiece input,
                                           StringPiece separators,
                                           WhitespaceHandling whitespace,
                                           SplitResult result_type) {
-  return SplitStringT<StringPiece>(input, separators, whitespace, result_type);
+  return internal::SplitStringT<StringPiece>(input, separators, whitespace,
+                                             result_type);
 }
 
 std::vector<StringPiece16> SplitStringPiece(StringPiece16 input,
                                             StringPiece16 separators,
                                             WhitespaceHandling whitespace,
                                             SplitResult result_type) {
-  return SplitStringT<StringPiece16>(input, separators, whitespace,
-                                     result_type);
+  return internal::SplitStringT<StringPiece16>(input, separators, whitespace,
+                                               result_type);
 }
 
 bool SplitStringIntoKeyValuePairs(StringPiece input,
@@ -192,16 +114,16 @@ std::vector<string16> SplitStringUsingSubstr(StringPiece16 input,
                                              StringPiece16 delimiter,
                                              WhitespaceHandling whitespace,
                                              SplitResult result_type) {
-  return SplitStringUsingSubstrT<string16>(input, delimiter, whitespace,
-                                           result_type);
+  return internal::SplitStringUsingSubstrT<string16>(input, delimiter,
+                                                     whitespace, result_type);
 }
 
 std::vector<std::string> SplitStringUsingSubstr(StringPiece input,
                                                 StringPiece delimiter,
                                                 WhitespaceHandling whitespace,
                                                 SplitResult result_type) {
-  return SplitStringUsingSubstrT<std::string>(input, delimiter, whitespace,
-                                              result_type);
+  return internal::SplitStringUsingSubstrT<std::string>(
+      input, delimiter, whitespace, result_type);
 }
 
 std::vector<StringPiece16> SplitStringPieceUsingSubstr(
@@ -210,8 +132,8 @@ std::vector<StringPiece16> SplitStringPieceUsingSubstr(
     WhitespaceHandling whitespace,
     SplitResult result_type) {
   std::vector<StringPiece16> result;
-  return SplitStringUsingSubstrT<StringPiece16>(input, delimiter, whitespace,
-                                                result_type);
+  return internal::SplitStringUsingSubstrT<StringPiece16>(
+      input, delimiter, whitespace, result_type);
 }
 
 std::vector<StringPiece> SplitStringPieceUsingSubstr(
@@ -219,41 +141,8 @@ std::vector<StringPiece> SplitStringPieceUsingSubstr(
     StringPiece delimiter,
     WhitespaceHandling whitespace,
     SplitResult result_type) {
-  return SplitStringUsingSubstrT<StringPiece>(input, delimiter, whitespace,
-                                              result_type);
-}
-
-#if defined(OS_WIN) && defined(BASE_STRING16_IS_STD_U16STRING)
-std::vector<std::wstring> SplitString(WStringPiece input,
-                                      WStringPiece separators,
-                                      WhitespaceHandling whitespace,
-                                      SplitResult result_type) {
-  return SplitStringT<std::wstring>(input, separators, whitespace, result_type);
-}
-
-std::vector<WStringPiece> SplitStringPiece(WStringPiece input,
-                                           WStringPiece separators,
-                                           WhitespaceHandling whitespace,
-                                           SplitResult result_type) {
-  return SplitStringT<WStringPiece>(input, separators, whitespace, result_type);
-}
-
-std::vector<std::wstring> SplitStringUsingSubstr(WStringPiece input,
-                                                 WStringPiece delimiter,
-                                                 WhitespaceHandling whitespace,
-                                                 SplitResult result_type) {
-  return SplitStringUsingSubstrT<std::wstring>(input, delimiter, whitespace,
-                                               result_type);
-}
-
-std::vector<WStringPiece> SplitStringPieceUsingSubstr(
-    WStringPiece input,
-    WStringPiece delimiter,
-    WhitespaceHandling whitespace,
-    SplitResult result_type) {
-  return SplitStringUsingSubstrT<WStringPiece>(input, delimiter, whitespace,
-                                               result_type);
+  return internal::SplitStringUsingSubstrT<StringPiece>(
+      input, delimiter, whitespace, result_type);
 }
-#endif
 
 }  // namespace base