Use base::StringPairs where appropriate from src/chrome/browser

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>
 
@@ skipping 513 matching lines @@
   // There is no pending cleanup task for the modern hash stores.
   EXPECT_FALSE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_FALSE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_PROTECTED_PREF_STORE));
 
   // Both stores were modified as hashes were moved from Local State.
   EXPECT_TRUE(StoreModifiedByMigration(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(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 55 matching lines @@
   EXPECT_TRUE(ContainsLegacyHash(kProtectedPref));
   EXPECT_TRUE(ContainsLegacyHash(kPreviouslyProtectedPref));
 
   // Perform a first-pass migration.
   HandPrefsToMigrator(MOCK_UNPROTECTED_PREF_STORE);
   HandPrefsToMigrator(MOCK_PROTECTED_PREF_STORE);
   EXPECT_TRUE(MigrationCompleted());
 
   // All values should have been moved to their preferred locations, including
   // MACs.
-  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));
   expected_unprotected_values.push_back(
       std::make_pair(kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
-  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));
   expected_protected_values.push_back(std::make_pair(
       kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
 
   VerifyValuesStored(MOCK_UNPROTECTED_PREF_STORE, expected_unprotected_values);
   VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
 
   EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
   EXPECT_TRUE(
@@ skipping 100 matching lines @@
   EXPECT_TRUE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_PROTECTED_PREF_STORE));
   EXPECT_TRUE(StoreModifiedByMigration(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(StoreModifiedByMigration(MOCK_PROTECTED_PREF_STORE));
 
   // Values should have been migrated to their store, but migrated values should
   // still remain in the source store until cleanup tasks are later invoked.
   {
-    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));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     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));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
 
     EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyUnprotectedPref));
     EXPECT_FALSE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kProtectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyProtectedPref));
 
     EXPECT_FALSE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kUnprotectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_PROTECTED_PREF_STORE, kPreviouslyUnprotectedPref));
     EXPECT_TRUE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kProtectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_PROTECTED_PREF_STORE, kPreviouslyProtectedPref));
   }
 
   // A successful write of the protected pref store should result in a clean up
   // of the unprotected store.
   SimulateSuccessfulWrite(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));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     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));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 
   SimulateSuccessfulWrite(MOCK_UNPROTECTED_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));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     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));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 
   // Hashes are not cleaned up yet.
   EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
   EXPECT_TRUE(
@@ skipping 63 matching lines @@
   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));
 
   // Cleanup should happen synchronously if the values were already present in
   // their destination stores.
   {
-    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));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     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));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 }