Don't use path expansion for profile dictionaries in LocalState

chrome/browser/prefs/pref_metrics_service.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_metrics_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/metrics/histogram.h"
@@ skipping 266 matching lines @@
 // profile. To make the system more resistant to spoofing, pref values are
 // hashed with the pref path and the device id.
 void PrefMetricsService::CheckTrackedPreferences() {
   DCHECK(!checked_tracked_prefs_);
 
   const base::DictionaryValue* pref_hash_dicts =
       local_state_->GetDictionary(prefs::kProfilePreferenceHashes);
   // Get the hashed prefs dictionary if it exists. If it doesn't, it will be
   // created if we set preference values below.
   const base::DictionaryValue* hashed_prefs = NULL;
-  pref_hash_dicts->GetDictionary(profile_name_, &hashed_prefs);
+  pref_hash_dicts->GetDictionaryWithoutPathExpansion(profile_name_,

[battre, 2013/09/12 08:38:47]

This is pretty error prone. Can you please update the unit tests to use a
directory that contains a period?

[michaelpg, 2013/09/14 18:18:32]

Done.

+                                                     &hashed_prefs);
   for (int i = 0; i < tracked_pref_path_count_; ++i) {
     // Skip prefs that haven't been registered.
     if (!prefs_->FindPreference(tracked_pref_paths_[i]))
       continue;
 
     bool changed = false;
     const base::Value* value = prefs_->GetUserPrefValue(tracked_pref_paths_[i]);
     if (value) {
       std::string value_hash =
           GetHashedPrefValue(tracked_pref_paths_[i], value);
@@ skipping 39 matching lines @@
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame)) {
     InitializePrefObservers();
   }
 }
 
 void PrefMetricsService::UpdateTrackedPreference(const char* path) {
   const base::Value* value = prefs_->GetUserPrefValue(path);
   if (value) {
     DictionaryPrefUpdate update(local_state_, prefs::kProfilePreferenceHashes);
-    update->SetString(GetHashedPrefPath(path),
-                      GetHashedPrefValue(path, value));
+    DictionaryValue* child_dictionary = NULL;
+
+    // Get the dictionary corresponding to the profile name,
+    // which may have a .

[xiyuan, 2013/09/12 16:18:37]

nit: which may have a '.'.

[michaelpg, 2013/09/14 18:18:32]

Done.

+    if (!update->GetDictionaryWithoutPathExpansion(profile_name_,
+                                                   &child_dictionary)) {
+      child_dictionary = new DictionaryValue;
+      update->SetWithoutPathExpansion(profile_name_, child_dictionary);
+    }
+    child_dictionary->SetString(path, GetHashedPrefValue(path, value));
   } else {
     RemoveTrackedPreference(path);
   }
 }
 
 bool PrefMetricsService::RemoveTrackedPreference(const char* path) {
   DictionaryPrefUpdate update(local_state_, prefs::kProfilePreferenceHashes);
-  return update->Remove(GetHashedPrefPath(path), NULL);
-}
+  DictionaryValue* child_dictionary = NULL;
 
-std::string PrefMetricsService::GetHashedPrefPath(const char* path) {
-  std::string hash_pref_path(profile_name_);
-  hash_pref_path.append(".");
-  hash_pref_path.append(path);
-  return hash_pref_path;
+  if (!update->GetDictionaryWithoutPathExpansion(profile_name_,
+                                                 &child_dictionary)) {
+    return false;
+  }
+  return child_dictionary->Remove(path, NULL);
 }
 
 std::string PrefMetricsService::GetHashedPrefValue(
     const char* path,
     const base::Value* value) {
   DCHECK(value);
 
   // Dictionary values may contain empty lists and sub-dictionaries. Create
   // a deep copy with those stripped to make the hash more stable.
   scoped_ptr<DictionaryValue> dict_value;
@@ skipping 66 matching lines @@
 }
 
 bool PrefMetricsService::Factory::ServiceIsNULLWhileTesting() const {
   return false;
 }
 
 content::BrowserContext* PrefMetricsService::Factory::GetBrowserContextToUse(
     content::BrowserContext* context) const {
   return chrome::GetBrowserContextRedirectedInIncognito(context);
 }