Added StringPiece overloads for base::JoinString.

base/strings/string_util.cc

 // Copyright 2013 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_util.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <math.h>
 #include <stdarg.h>
@@ skipping 835 matching lines @@
 }
 
 char* WriteInto(std::string* str, size_t length_with_null) {
   return WriteIntoT(str, length_with_null);
 }
 
 char16* WriteInto(string16* str, size_t length_with_null) {
   return WriteIntoT(str, length_with_null);
 }
 
-template<typename STR>
+template <typename STR>
 static STR JoinStringT(const std::vector<STR>& parts,
                        BasicStringPiece<STR> sep) {
   if (parts.empty())
     return STR();
 
   STR result(parts[0]);
   auto iter = parts.begin();
   ++iter;
 
   for (; iter != parts.end(); ++iter) {
     sep.AppendToString(&result);
     result += *iter;
   }
 
   return result;
 }
 
+template <typename STR>
+static STR JoinStringPieceT(const std::vector<BasicStringPiece<STR>>& parts,
+                            BasicStringPiece<STR> sep) {
+  if (parts.empty())
+    return STR();
+
+  STR result(parts[0].data(), parts[0].size());
+  auto iter = parts.begin();
+  ++iter;
+
+  for (; iter != parts.end(); ++iter) {
+    sep.AppendToString(&result);

[danakj, 2017/02/16 16:34:32]

Just throwing it out there, not for this CL, but: It's unfortunate these are
going to grow the string's size 2N-1 times. We could figure out the size of all
the strings appended together, resize() the result to that, and then fill it in.

[danakj, 2017/02/16 16:36:21]

Ohh I see actually at the site that you deleted they used reserve(). I didn't
realize string has that. We could use that for all join implementations.

[Matt Giuca, 2017/02/16 23:51:11]

Yes! Maybe you missed this in my original email:
I think we should do it -- it's probably faster but there is a performance
trade-off here (iterating over the vector twice) so we maybe should profile it
first. I'll do that as a separate CL.

[danakj, 2017/02/16 23:53:28]

Oops, ya I missed that. I super doubt walking the vector and calling size can
compare to calling realloc even one time. But we should do it in both methods
not just the StringPiece one, so ya let's do it as a separate CL.

+    iter->AppendToString(&result);
+  }
+
+  return result;
+}
+
 std::string JoinString(const std::vector<std::string>& parts,
                        StringPiece separator) {
   return JoinStringT(parts, separator);
 }
 
 string16 JoinString(const std::vector<string16>& parts,
                     StringPiece16 separator) {
   return JoinStringT(parts, separator);
 }
 
+std::string JoinStringPiece(const std::vector<StringPiece>& parts,
+                            StringPiece separator) {
+  return JoinStringPieceT(parts, separator);
+}
+
+string16 JoinStringPiece(const std::vector<StringPiece16>& parts,
+                         StringPiece16 separator) {
+  return JoinStringPieceT(parts, separator);
+}
+
 template<class FormatStringType, class OutStringType>
 OutStringType DoReplaceStringPlaceholders(
     const FormatStringType& format_string,
     const std::vector<OutStringType>& subst,
     std::vector<size_t>* offsets) {
   size_t substitutions = subst.size();
   DCHECK_LT(substitutions, 10U);
 
   size_t sub_length = 0;
   for (const auto& cur : subst)
@@ skipping 94 matching lines @@
 }  // namespace
 
 size_t strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }
 
 }  // namespace base