Don't unnecessarily copy strings

base/strings/string_split.cc

 // Copyright (c) 2012 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 "base/strings/string_split.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/third_party/icu/icu_utf.h"
 
@@ skipping 110 matching lines @@
   if (begin_value_pos == StringPiece::npos) {
     DVLOG(1) << "cannot parse value from input: " << input;
     return false;   // No value.
   }
   remains.substr(begin_value_pos, remains.size() - begin_value_pos)
       .CopyToString(&result_pair.second);
 
   return true;
 }
 
-template <typename Str>
+template <typename Str, typename OutputStringType>
 void SplitStringUsingSubstrT(BasicStringPiece<Str> input,
                              BasicStringPiece<Str> delimiter,
-                             std::vector<Str>* result) {
+                             std::vector<OutputStringType>* result) {
   using Piece = BasicStringPiece<Str>;
   using size_type = typename Piece::size_type;
 
   result->clear();
   size_type begin_index = 0;
   while (true) {
     size_type end_index = input.find(delimiter, begin_index);
     if (end_index == Piece::npos) {
       // No delimiter, use the rest of the string.
       Piece term = TrimString(input.substr(begin_index),
                               WhitespaceForType<Str>(), TRIM_ALL);
-      result->push_back(term.as_string());
+      result->push_back(PieceToOutputType<Str, OutputStringType>(term));
       return;
     }
     Piece term = TrimString(input.substr(begin_index, end_index - begin_index),
                             WhitespaceForType<Str>(), TRIM_ALL);
-    result->push_back(term.as_string());
+    result->push_back(PieceToOutputType<Str, OutputStringType>(term));
     begin_index = end_index + delimiter.size();
   }
 }
 
 }  // namespace
 
 std::vector<std::string> SplitString(StringPiece input,
                                      StringPiece separators,
                                      WhitespaceHandling whitespace,
                                      SplitResult result_type) {
@@ skipping 68 matching lines @@
                             std::vector<string16>* result) {
   SplitStringUsingSubstrT(input, delimiter, result);
 }
 
 void SplitStringUsingSubstr(StringPiece input,
                             StringPiece delimiter,
                             std::vector<std::string>* result) {
   SplitStringUsingSubstrT(input, delimiter, result);
 }
 
+std::vector<StringPiece16> SplitStringPieceUsingSubstr(
+    StringPiece16 input,
+    StringPiece16 delimiter) {

[mef, 2015/12/28 17:29:55]

Would it make sense to take a pointer to an output vector as a parameter to
avoid copying it on the return?

[brettw, 2015/12/29 04:07:14]

Return value optimization should take care of this: there should be no copy when
used in most cases.

[mef, 2015/12/30 19:36:58]

Acknowledged.

+  std::vector<StringPiece16> result;
+  SplitStringUsingSubstrT(input, delimiter, &result);
+  return result;
+}
+
+std::vector<StringPiece> SplitStringPieceUsingSubstr(StringPiece input,
+                                                     StringPiece delimiter) {
+  std::vector<StringPiece> result;
+  SplitStringUsingSubstrT(input, delimiter, &result);
+  return result;
+}
+
 }  // namespace base