Use base::StringPairs where appropriate from /chrome

chrome/browser/prefs/tracked/tracked_preferences_migration_unittest.cc

 // Copyright 2014 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 "chrome/browser/prefs/tracked/tracked_preferences_migration.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/testing_pref_service.h"
+#include "base/strings/string_split.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/interceptable_pref_filter.h"
 #include "chrome/browser/prefs/pref_hash_store.h"
 #include "chrome/browser/prefs/pref_hash_store_impl.h"
 #include "chrome/browser/prefs/pref_hash_store_transaction.h"
 #include "chrome/browser/prefs/profile_pref_store_manager.h"
 #include "chrome/browser/prefs/tracked/dictionary_hash_store_contents.h"
 #include "chrome/browser/prefs/tracked/hash_store_contents.h"
 #include "chrome/browser/prefs/tracked/pref_service_hash_store_contents.h"
 #include "chrome/browser/prefs/tracked/tracked_preferences_migration.h"
@@ skipping 187 matching lines @@
         return !unprotected_store_successful_write_callback_.is_null();
     }
     NOTREACHED();
     return false;
   }
 
   // Verifies that the (key, value) pairs in |expected_prefs_in_store| are found
   // in the store identified by |store_id|.
   void VerifyValuesStored(
       MockPrefStoreID store_id,
-      const std::vector<std::pair<std::string, std::string> >&
-          expected_prefs_in_store) {
+      const base::StringPairs& expected_prefs_in_store) {
     base::DictionaryValue* store = NULL;
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         store = unprotected_prefs_.get();
         break;
       case MOCK_PROTECTED_PREF_STORE:
         store = protected_prefs_.get();
         break;
     }
     DCHECK(store);
 
-    for (std::vector<std::pair<std::string, std::string> >::const_iterator it =
-             expected_prefs_in_store.begin();
+    for (base::StringPairs::const_iterator it = expected_prefs_in_store.begin();
          it != expected_prefs_in_store.end(); ++it) {
       std::string val;
       EXPECT_TRUE(store->GetString(it->first, &val));
       EXPECT_EQ(it->second, val);
     }
   }
 
   // Determines whether |expected_pref_in_hash_store| has a hash in the hash
   // store identified by |store_id|.
   bool ContainsHash(MockPrefStoreID store_id,
@@ skipping 220 matching lines @@
   // Prefs should have been handed back over.
   EXPECT_TRUE(HasPrefs(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(HasPrefs(MOCK_PROTECTED_PREF_STORE));
   EXPECT_FALSE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_FALSE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_PROTECTED_PREF_STORE));
   EXPECT_FALSE(StoreModifiedByMigration(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_FALSE(StoreModifiedByMigration(MOCK_PROTECTED_PREF_STORE));
 
-  std::vector<std::pair<std::string, std::string> > expected_unprotected_values;
+  base::StringPairs expected_unprotected_values;
   expected_unprotected_values.push_back(
       std::make_pair(kUnprotectedPref, kUnprotectedPrefValue));
   VerifyValuesStored(MOCK_UNPROTECTED_PREF_STORE, expected_unprotected_values);
 
-  std::vector<std::pair<std::string, std::string> > expected_protected_values;
+  base::StringPairs expected_protected_values;
   expected_protected_values.push_back(
       std::make_pair(kProtectedPref, kProtectedPrefValue));
   VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
 
   EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
   EXPECT_FALSE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kProtectedPref));
 
   EXPECT_TRUE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kProtectedPref));
   EXPECT_FALSE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kUnprotectedPref));
 }
@@ skipping 411 matching lines @@
                        expected_unprotected_values);
 
     std::vector<std::pair<std::string, std::string> > expected_protected_values;
     expected_protected_values.push_back(std::make_pair(
         kProtectedPref, kProtectedPrefValue));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 }