All Get/Set using the hash_store_id as a key should use *WithoutPathExpansion methods

chrome/browser/prefs/pref_hash_store_impl.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 "chrome/browser/prefs/pref_hash_store_impl.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
@@ skipping 72 matching lines @@
 void PrefHashStoreImpl::Reset() {
   DictionaryPrefUpdate update(local_state_, prefs::kProfilePreferenceHashes);
 
   // Remove the dictionary corresponding to the profile name, which may have a
   // '.'
   update->RemoveWithoutPathExpansion(hash_store_id_, NULL);
 
   // Remove this store's entry in the kStoreVersionsDict.
   base::DictionaryValue* version_dict;
   if (update->GetDictionary(internals::kStoreVersionsDict, &version_dict))
-    version_dict->Remove(hash_store_id_, NULL);
+    version_dict->RemoveWithoutPathExpansion(hash_store_id_, NULL);
 
   // Remove this store's entry in the kHashOfHashesDict.
   base::DictionaryValue* hash_of_hashes_dict;
   if (update->GetDictionaryWithoutPathExpansion(internals::kHashOfHashesDict,
                                                 &hash_of_hashes_dict)) {
-    hash_of_hashes_dict->Remove(hash_store_id_, NULL);
+    hash_of_hashes_dict->RemoveWithoutPathExpansion(hash_store_id_, NULL);
   }
 }
 
 scoped_ptr<PrefHashStoreTransaction> PrefHashStoreImpl::BeginTransaction() {
   return scoped_ptr<PrefHashStoreTransaction>(
       new PrefHashStoreTransactionImpl(this));
 }
 
 PrefHashStoreImpl::StoreVersion PrefHashStoreImpl::GetCurrentVersion() const {
   const base::DictionaryValue* pref_hash_data =
       local_state_->GetDictionary(prefs::kProfilePreferenceHashes);
 
   if (!pref_hash_data->GetDictionaryWithoutPathExpansion(hash_store_id_, NULL))
     return VERSION_UNINITIALIZED;
 
   const base::DictionaryValue* version_dict;
   int current_version;
   if (!pref_hash_data->GetDictionary(internals::kStoreVersionsDict,
                                      &version_dict) ||
-      !version_dict->GetInteger(hash_store_id_, &current_version)) {
+      !version_dict->GetIntegerWithoutPathExpansion(hash_store_id_,
+                                                    &current_version)) {
     return VERSION_PRE_MIGRATION;
   }
 
   DCHECK_GT(current_version, VERSION_PRE_MIGRATION);
   return static_cast<StoreVersion>(current_version);
 }
 
 bool PrefHashStoreImpl::IsHashDictionaryTrusted() const {
   const base::DictionaryValue* pref_hash_data =
       local_state_->GetDictionary(prefs::kProfilePreferenceHashes);
@@ skipping 52 matching lines @@
   // practice only initialization transactions will actually do this, but
   // since they always occur before minor update transaction it's okay
   // to unconditionally do this here). Do this even if |!has_changed_| to also
   // seed version number on unchanged profiles.
   base::DictionaryValue* store_versions_dict = NULL;
   if (!update->GetDictionary(internals::kStoreVersionsDict,
                              &store_versions_dict)) {
     store_versions_dict = new base::DictionaryValue;
     update->Set(internals::kStoreVersionsDict, store_versions_dict);
   }
-  store_versions_dict->SetInteger(outer_->hash_store_id_, VERSION_LATEST);
+  store_versions_dict->SetIntegerWithoutPathExpansion(outer_->hash_store_id_,
+                                                      VERSION_LATEST);
 }
 
 PrefHashStoreTransaction::ValueState
 PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckValue(
     const std::string& path, const base::Value* initial_value) const {
   const base::DictionaryValue* pref_hash_data =
       outer_->local_state_->GetDictionary(prefs::kProfilePreferenceHashes);
   const base::DictionaryValue* hashed_prefs = NULL;
   pref_hash_data->GetDictionaryWithoutPathExpansion(outer_->hash_store_id_,
                                                      &hashed_prefs);
@@ skipping 140 matching lines @@
   if (!update->Get()->GetDictionaryWithoutPathExpansion(outer_->hash_store_id_,
                                                         &hashes_dict)) {
     hashes_dict = new base::DictionaryValue;
     update->Get()->SetWithoutPathExpansion(outer_->hash_store_id_, hashes_dict);
   }
   hashes_dict->SetString(
       path, outer_->pref_hash_calculator_.Calculate(path, new_value));
 
   has_changed_ = true;
 }