Enforce SafetyMode for YouTube if prefs::kForceSafeSearch is on.

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 599 matching lines @@
 std::string JoinString(const std::vector<std::string>& parts,
                        const std::string& separator) {
   return JoinStringT(parts, separator);
 }
 
 string16 JoinString(const std::vector<string16>& parts,
                     const string16& separator) {
   return JoinStringT(parts, separator);
 }
 
+static std::string JoinStringKeyValuePair(

[erikwright (departed), 2014/07/10 14:26:24]

These methods are only used from a single file AFAICT.

They seem relatively specialized (i.e., many application might require escaping,
etc).

There also are no tests for them.

Personally I suggest just moving them to the anonymous namespace in the file
that uses them. Otherwise tests would be required.

In any case I would expect the owners of base to object to their addition with a
single client. OTOH, if you can find some existing code that could be replaced
with this, more power to you!

[Marc Treib, 2014/07/10 15:40:39]

I moved these functions into safe_search_util.cc.

+    const StringPairs::value_type& key_value,
+    char delimiter) {
+  return key_value.first + delimiter + key_value.second;
+}
+
+std::string JoinStringKeyValuePairs(const StringPairs& pairs,
+                                    char key_value_delimiter,
+                                    char key_value_pair_delimiter) {
+  if (pairs.empty())
+    return std::string();
+
+  StringPairs::const_iterator it = pairs.begin();
+  std::string result = JoinStringKeyValuePair(*it, key_value_delimiter);
+  ++it;
+
+  for (; it != pairs.end(); ++it) {
+    result += key_value_pair_delimiter;
+    result += JoinStringKeyValuePair(*it, key_value_delimiter);
+  }
+
+  return result;
+}
+
 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();
 
   size_t sub_length = 0;
   for (typename std::vector<OutStringType>::const_iterator iter = subst.begin();
        iter != subst.end(); ++iter) {
     sub_length += iter->length();
   }
@@ skipping 253 matching lines @@
 }
 
 }  // namespace
 
 size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }