Omnibox: Create DemoteByType Experiment

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/strings/utf_string_conversions.h"
 #include "base/third_party/icu/icu_utf.h"
@@ skipping 62 matching lines @@
     return false;   // no value
   }
   std::string values_string(remains, begin_values_pos,
                             remains.size() - begin_values_pos);
 
   // Construct the values vector.
   values->push_back(values_string);
   return true;
 }
 
-bool SplitStringIntoKeyValuePairs(
-    const std::string& line,
-    char key_value_delimiter,
-    char key_value_pair_delimiter,
-    std::vector<std::pair<std::string, std::string> >* kv_pairs) {
-  kv_pairs->clear();
+bool SplitStringIntoKeyValuePairs(const std::string& line,
+                                  char key_value_delimiter,
+                                  char key_value_pair_delimiter,
+                                  StringPairs* key_value_pairs) {
+  key_value_pairs->clear();
 
   std::vector<std::string> pairs;
   SplitString(line, key_value_pair_delimiter, &pairs);
 
   bool success = true;
   for (size_t i = 0; i < pairs.size(); ++i) {
     // Empty pair. SplitStringIntoKeyValues is more strict about an empty pair
     // line, so continue with the next pair.
     if (pairs[i].empty())
       continue;
 
     std::string key;
     std::vector<std::string> value;
     if (!SplitStringIntoKeyValues(pairs[i],
                                   key_value_delimiter,
                                   &key, &value)) {
       // Don't return here, to allow for keys without associated
       // values; just record that our split failed.
       success = false;
     }
     DCHECK_LE(value.size(), 1U);
-    kv_pairs->push_back(
+    key_value_pairs->push_back(
         make_pair(key, value.empty() ? std::string() : value[0]));
   }
   return success;
 }
 
 template <typename STR>
 static void SplitStringUsingSubstrT(const STR& str,
                                     const STR& s,
                                     std::vector<STR>* r) {
   r->clear();
@@ skipping 90 matching lines @@
                                 std::vector<string16>* result) {
   SplitStringAlongWhitespaceT(str, result);
 }
 
 void SplitStringAlongWhitespace(const std::string& str,
                                 std::vector<std::string>* result) {
   SplitStringAlongWhitespaceT(str, result);
 }
 
 }  // namespace base