Add TrackedPreferenceValidationDelegate

chrome/browser/prefs/profile_pref_store_manager.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/profile_pref_store_manager.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/persistent_pref_store.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "chrome/browser/prefs/pref_hash_store_impl.h"
 #include "chrome/browser/prefs/tracked/pref_service_hash_store_contents.h"
 #include "chrome/browser/prefs/tracked/segregated_pref_store.h"
+#include "chrome/browser/prefs/tracked/tracked_preference_validation_observer.h"
 #include "chrome/browser/prefs/tracked/tracked_preferences_migration.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 
 namespace {
 
 // An adaptor that allows a PrefHashStoreImpl to access a preference store
 // directly as a dictionary. Uses an equivalent layout to
 // PrefStoreHashStoreContents.
@@ skipping 147 matching lines @@
 void InitializeHashStoreObserver::OnPrefValueChanged(const std::string& key) {}
 
 void InitializeHashStoreObserver::OnInitializationCompleted(bool succeeded) {
   // If we successfully loaded the preferences _and_ the PrefHashStoreImpl
   // hasn't been initialized by someone else in the meantime, initialize it now.
   const PrefHashStoreImpl::StoreVersion pre_update_version =
       pref_hash_store_impl_->GetCurrentVersion();
   if (succeeded && pre_update_version < PrefHashStoreImpl::VERSION_LATEST) {
     PrefHashFilter(pref_hash_store_impl_.PassAs<PrefHashStore>(),
                    tracking_configuration_,
+                   scoped_ptr<TrackedPreferenceValidationObserver>(),
                    reporting_ids_count_).Initialize(*pref_store_);
     UMA_HISTOGRAM_ENUMERATION(
         "Settings.TrackedPreferencesAlternateStoreVersionUpdatedFrom",
         pre_update_version,
         PrefHashStoreImpl::VERSION_LATEST + 1);
   }
   pref_store_->RemoveObserver(this);
   delete this;
 }
 
+// A TrackedPreferenceValidationObserver that delegates to another shared
+// observer instance.
+class DelegatingValidationObserver

[Mattias Nissler (ping if slow), 2014/05/15 14:32:25]

Ah, so this is where the ownership awkwardness happens get handled. If the
PrefHashFilter wouldn't own the observer, you could just pass the same pointer
to both instances, no?

[grt (UTC plus 2), 2014/05/15 18:21:35]

Yes. This introduces other issues that Erik has already pointed out.

+    : public TrackedPreferenceValidationObserver {
+ public:
+  // A reference-counted holder of a TrackedPreferenceValidationObserver.
+  class RefCountedObserver : public base::RefCounted<RefCountedObserver> {
+   public:
+    explicit RefCountedObserver(
+        scoped_ptr<TrackedPreferenceValidationObserver> observer);
+    TrackedPreferenceValidationObserver* get();
+
+   private:
+    friend class base::RefCounted<RefCountedObserver>;
+    ~RefCountedObserver();
+
+    scoped_ptr<TrackedPreferenceValidationObserver> observer_;
+  };
+
+  explicit DelegatingValidationObserver(
+      const scoped_refptr<RefCountedObserver>& observer);
+  virtual ~DelegatingValidationObserver();
+
+  // TrackedPreferenceValidationObserver methods.
+  virtual void OnAtomicPreferenceValidation(
+      const std::string& pref_path,
+      const base::Value* value,
+      PrefHashStoreTransaction::ValueState value_state,
+      TrackedPreferenceHelper::ResetAction reset_action) OVERRIDE;
+  virtual void OnSplitPreferenceValidation(
+      const std::string& pref_path,
+      const base::DictionaryValue* dict_value,
+      const std::vector<std::string>& invalid_keys,
+      PrefHashStoreTransaction::ValueState value_state,
+      TrackedPreferenceHelper::ResetAction reset_action) OVERRIDE;
+
+ private:
+  scoped_refptr<RefCountedObserver> observer_;
+  DISALLOW_COPY_AND_ASSIGN(DelegatingValidationObserver);
+};
+
+DelegatingValidationObserver::RefCountedObserver::RefCountedObserver(
+    scoped_ptr<TrackedPreferenceValidationObserver> observer)
+    : observer_(observer.Pass()) {
+}
+
+DelegatingValidationObserver::RefCountedObserver::~RefCountedObserver() {
+}
+
+TrackedPreferenceValidationObserver*
+DelegatingValidationObserver::RefCountedObserver::get() {
+  return observer_.get();
+}
+
+DelegatingValidationObserver::DelegatingValidationObserver(
+    const scoped_refptr<RefCountedObserver>& observer)
+    : observer_(observer) {
+}
+
+DelegatingValidationObserver::~DelegatingValidationObserver() {
+}
+
+void DelegatingValidationObserver::OnAtomicPreferenceValidation(
+    const std::string& pref_path,
+    const base::Value* value,
+    PrefHashStoreTransaction::ValueState value_state,
+    TrackedPreferenceHelper::ResetAction reset_action) {
+  observer_->get()->OnAtomicPreferenceValidation(
+      pref_path, value, value_state, reset_action);
+}
+
+void DelegatingValidationObserver::OnSplitPreferenceValidation(
+    const std::string& pref_path,
+    const base::DictionaryValue* dict_value,
+    const std::vector<std::string>& invalid_keys,
+    PrefHashStoreTransaction::ValueState value_state,
+    TrackedPreferenceHelper::ResetAction reset_action) {
+  observer_->get()->OnSplitPreferenceValidation(
+      pref_path, dict_value, invalid_keys, value_state, reset_action);
+}
+
 }  // namespace
 
 // TODO(erikwright): Enable this on Chrome OS and Android once MACs are moved
 // out of Local State. This will resolve a race condition on Android and a
 // privacy issue on ChromeOS. http://crbug.com/349158
 const bool ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking =
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
     false;
 #else
     true;
@@ skipping 47 matching lines @@
 void ProfilePrefStoreManager::ClearResetTime(PrefService* pref_service) {
   PrefHashFilter::ClearResetTime(pref_service);
 }
 
 void ProfilePrefStoreManager::ResetPrefHashStore() {
   if (kPlatformSupportsPreferenceTracking)
     GetPrefHashStoreImpl()->Reset();
 }
 
 PersistentPrefStore* ProfilePrefStoreManager::CreateProfilePrefStore(
-    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) {
+    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
+    scoped_ptr<TrackedPreferenceValidationObserver> verification_observer) {
   scoped_ptr<PrefFilter> pref_filter;
   if (!kPlatformSupportsPreferenceTracking) {
     return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
                              io_task_runner,
                              scoped_ptr<PrefFilter>());
   }
 
   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
       unprotected_configuration;
   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
       protected_configuration;
   std::set<std::string> protected_pref_names;
   std::set<std::string> unprotected_pref_names;
   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::const_iterator
            it = tracking_configuration_.begin();
        it != tracking_configuration_.end();
        ++it) {
     if (it->enforcement_level > PrefHashFilter::NO_ENFORCEMENT) {
       protected_configuration.push_back(*it);
       protected_pref_names.insert(it->name);
     } else {
       unprotected_configuration.push_back(*it);
       unprotected_pref_names.insert(it->name);
     }
   }
 
-  scoped_ptr<PrefHashFilter> unprotected_pref_hash_filter(
-      new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
-                         unprotected_configuration,
-                         reporting_ids_count_));
-  scoped_ptr<PrefHashFilter> protected_pref_hash_filter(
-      new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
-                         protected_configuration,
-                         reporting_ids_count_));
+  scoped_refptr<DelegatingValidationObserver::RefCountedObserver> observer;
+  if (verification_observer) {
+    observer = new DelegatingValidationObserver::RefCountedObserver(
+        verification_observer.Pass());
+  }
+
+  scoped_ptr<PrefHashFilter> unprotected_pref_hash_filter(new PrefHashFilter(
+      GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
+      unprotected_configuration,
+      observer ?
+          scoped_ptr<TrackedPreferenceValidationObserver>(
+              new DelegatingValidationObserver(observer)) :
+          scoped_ptr<TrackedPreferenceValidationObserver>(),
+      reporting_ids_count_));
+  scoped_ptr<PrefHashFilter> protected_pref_hash_filter(new PrefHashFilter(
+      GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
+      protected_configuration,
+      observer ?
+          scoped_ptr<TrackedPreferenceValidationObserver>(
+              new DelegatingValidationObserver(observer)) :
+          scoped_ptr<TrackedPreferenceValidationObserver>(),
+      reporting_ids_count_));
 
   PrefHashFilter* raw_unprotected_pref_hash_filter =
       unprotected_pref_hash_filter.get();
   PrefHashFilter* raw_protected_pref_hash_filter =
       protected_pref_hash_filter.get();
 
   scoped_refptr<JsonPrefStore> unprotected_pref_store(
       new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
                         io_task_runner,
                         unprotected_pref_hash_filter.PassAs<PrefFilter>()));
@@ skipping 63 matching lines @@
   // complete before Chrome can start (as master preferences seed the Local
   // State and Preferences files). This won't trip ThreadIORestrictions as they
   // won't have kicked in yet on the main thread.
   bool success = serializer.Serialize(master_prefs);
 
   if (success && kPlatformSupportsPreferenceTracking) {
     scoped_refptr<const PrefStore> pref_store(
         new DictionaryPrefStore(&master_prefs));
     PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
                    tracking_configuration_,
+                   scoped_ptr<TrackedPreferenceValidationObserver>(),
                    reporting_ids_count_).Initialize(*pref_store);
   }
 
   UMA_HISTOGRAM_BOOLEAN("Settings.InitializedFromMasterPrefs", success);
   return success;
 }
 
 PersistentPrefStore*
 ProfilePrefStoreManager::CreateDeprecatedCombinedProfilePrefStore(
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) {
   scoped_ptr<PrefFilter> pref_filter;
   if (kPlatformSupportsPreferenceTracking) {
     pref_filter.reset(
         new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
                            tracking_configuration_,
+                           scoped_ptr<TrackedPreferenceValidationObserver>(),
                            reporting_ids_count_));
   }
   return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
                            io_task_runner,
                            pref_filter.Pass());
 }
 
 scoped_ptr<PrefHashStoreImpl> ProfilePrefStoreManager::GetPrefHashStoreImpl() {
   DCHECK(kPlatformSupportsPreferenceTracking);
 
   return make_scoped_ptr(new PrefHashStoreImpl(
       seed_,
       device_id_,
       scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
           profile_path_.AsUTF8Unsafe(), local_state_))));
 }