Fix a race condition in preference metric reporting.

chrome/browser/prefs/hashed_pref_store.cc

Index: chrome/browser/prefs/hashed_pref_store.cc
diff --git a/chrome/browser/prefs/hashed_pref_store.cc b/chrome/browser/prefs/hashed_pref_store.cc
new file mode 100644
index 0000000000000000000000000000000000000000..764bb73e88c5396d244c6563cd718585c36151f9
--- /dev/null
+++ b/chrome/browser/prefs/hashed_pref_store.cc
@@ -0,0 +1,184 @@
+// Copyright (c) 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/hashed_pref_store.h"
+
+#include "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "base/values.h"
+#include "chrome/browser/prefs/pref_hash_store.h"
+#include "chrome/common/pref_names.h"
+
+namespace {
+
+// These preferences must be kept in sync with the TrackedPreference enum in
+// tools/metrics/histograms/histograms.xml. To add a new preference, append it
+// to the array and add a corresponding value to the histogram enum.
+const char* kTrackedPrefs[] = {
+  prefs::kShowHomeButton,
+  prefs::kHomePageIsNewTabPage,
+  prefs::kHomePage,
+  prefs::kRestoreOnStartup,
+  prefs::kURLsToRestoreOnStartup,
+  prefs::kExtensionsPref,
+  prefs::kGoogleServicesLastUsername,
+  prefs::kSearchProviderOverrides,
+  prefs::kDefaultSearchProviderSearchURL,
+  prefs::kDefaultSearchProviderKeyword,
+  prefs::kDefaultSearchProviderName,
+#if !defined(OS_ANDROID)
+  prefs::kPinnedTabs,
+#else
+  kUnregisteredPreference,
+#endif
+  prefs::kExtensionKnownDisabled,
+};
+
+}  // namespace
+
+HashedPrefStore::HashedPrefStore(
+    const scoped_refptr<PersistentPrefStore>& pref_store,
+    scoped_ptr<PrefHashStore> pref_hash_store)
+    : internal_observer_(pref_store, pref_hash_store.Pass()) {}
+
+bool HashedPrefStore::GetMutableValue(const std::string& key,
+                                      base::Value** result) {
+  return internal_observer_.wrapped_pref_store()->GetMutableValue(key, result);
+}
+
+void HashedPrefStore::ReportValueChanged(const std::string& key) {
+  internal_observer_.wrapped_pref_store()->ReportValueChanged(key);
+}
+
+void HashedPrefStore::SetValue(const std::string& key, base::Value* value) {
+  internal_observer_.wrapped_pref_store()->SetValue(key, value);
+}
+
+void HashedPrefStore::SetValueSilently(const std::string& key,
+                                       base::Value* value) {
+  internal_observer_.wrapped_pref_store()->SetValueSilently(key, value);
+}
+
+void HashedPrefStore::RemoveValue(const std::string& key) {
+  internal_observer_.wrapped_pref_store()->RemoveValue(key);
+}
+
+void HashedPrefStore::MarkNeedsEmptyValue(const std::string& key) {
+  internal_observer_.wrapped_pref_store()->MarkNeedsEmptyValue(key);
+}
+
+bool HashedPrefStore::ReadOnly() const {
+  return internal_observer_.wrapped_pref_store()->ReadOnly();
+}
+
+PersistentPrefStore::PrefReadError HashedPrefStore::GetReadError() const {
+  return internal_observer_.wrapped_pref_store()->GetReadError();
+}
+
+PersistentPrefStore::PrefReadError HashedPrefStore::ReadPrefs() {
+  return internal_observer_.wrapped_pref_store()->ReadPrefs();
+}
+
+void HashedPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) {
+  internal_observer_.wrapped_pref_store()->ReadPrefsAsync(error_delegate);
+}
+
+void HashedPrefStore::CommitPendingWrite() {
+  internal_observer_.wrapped_pref_store()->CommitPendingWrite();
+}
+
+void HashedPrefStore::AddObserver(Observer* observer) {
+  internal_observer_.observers().AddObserver(observer);
+}
+
+void HashedPrefStore::RemoveObserver(Observer* observer) {
+  internal_observer_.observers().RemoveObserver(observer);
+}
+
+bool HashedPrefStore::HasObservers() const {
+  return internal_observer_.observers().might_have_observers();
+}
+
+bool HashedPrefStore::IsInitializationComplete() const {
+  return internal_observer_.wrapped_pref_store()->IsInitializationComplete();
+}
+
+bool HashedPrefStore::GetValue(const std::string& key,
+                               const base::Value** result) const {
+  return internal_observer_.wrapped_pref_store()->GetValue(key, result);
+}
+
+void HashedPrefStore::PrefStoreObserver::OnPrefValueChanged(
+    const std::string& key) {
+  const base::Value* value = NULL;
+  wrapped_pref_store_->GetValue(key, &value);
+
+  pref_hash_store_->OnPrefValueChanged(key, value);
+
+  if (initialized_)
+    FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
+}
+
+void HashedPrefStore::PrefStoreObserver::OnInitializationCompleted(
+    bool succeeded) {
+  DCHECK(pref_hash_store_.get());
+  if (!pref_hash_store_.get())
+    return;
+
+  if (succeeded) {
+    for (size_t i = 0; i < arraysize(kTrackedPrefs); ++i) {
+      // TODO(erikwright): If it's important, have a pointer to the pref_service
+      // in order to skip things that aren't registered.
+      const base::Value* value = NULL;
+      wrapped_pref_store_->GetValue(kTrackedPrefs[i], &value);
+      PrefHashStore::InitializationResult initialization_result =
+          pref_hash_store_->InitializeTrackedValue(kTrackedPrefs[i], value);
+
+      switch (initialization_result) {
+        case PrefHashStore::UNCHANGED:
+          UMA_HISTOGRAM_ENUMERATION("Settings.TrackedPreferenceUnchanged",
+                                    i, arraysize(kTrackedPrefs));
+          break;
+        case PrefHashStore::CLEARED:
+          UMA_HISTOGRAM_ENUMERATION("Settings.TrackedPreferenceCleared",
+                                    i, arraysize(kTrackedPrefs));
+          break;
+        case PrefHashStore::MIGRATED:
+          UMA_HISTOGRAM_ENUMERATION("Settings.TrackedPreferenceMigrated",
+                                    i, arraysize(kTrackedPrefs));
+          break;
+        case PrefHashStore::CHANGED:
+          UMA_HISTOGRAM_ENUMERATION("Settings.TrackedPreferenceChanged",
+                                    i, arraysize(kTrackedPrefs));
+          break;
+        case PrefHashStore::INITIALIZED:
+          UMA_HISTOGRAM_ENUMERATION("Settings.TrackedPreferenceInitialized",
+                                    i, arraysize(kTrackedPrefs));
+          break;
+        default:
+          NOTREACHED() << "Unexpected PrefHashStore::InitializationResult: "
+                       << initialization_result;
+          break;
+      }
+    }
+  }
+
+  initialized_ = true;
+  FOR_EACH_OBSERVER(PrefStore::Observer,
+                    observers_,
+                    OnInitializationCompleted(succeeded));
+}
+
+HashedPrefStore::PrefStoreObserver::PrefStoreObserver(
+    const scoped_refptr<PersistentPrefStore>& wrapped_pref_store,
+    scoped_ptr<PrefHashStore> pref_hash_store)
+    : initialized_(false),
+      wrapped_pref_store_(wrapped_pref_store),
+      pref_hash_store_(pref_hash_store.Pass()) {
+  wrapped_pref_store_->AddObserver(this);
+}
+
+HashedPrefStore::PrefStoreObserver::~PrefStoreObserver() {
+  wrapped_pref_store_->RemoveObserver(this);
+}