Separate storage for protected preferences into Protected Preferences file.

chrome/browser/prefs/tracked/segregated_pref_store.h

Index: chrome/browser/prefs/tracked/segregated_pref_store.h
diff --git a/chrome/browser/prefs/tracked/segregated_pref_store.h b/chrome/browser/prefs/tracked/segregated_pref_store.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7bc6e9a8bfca7e8c6ade59d603e6c62bc1211e0
--- /dev/null
+++ b/chrome/browser/prefs/tracked/segregated_pref_store.h
@@ -0,0 +1,104 @@
+// 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.
+
+#ifndef CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_
+#define CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_
+
+#include <set>
+
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/observer_list.h"
+#include "base/prefs/persistent_pref_store.h"
+
+// Provides a unified PersistentPrefStore implementation that splits its storage
+// and retrieval between two underlying PersistentPrefStore instances: a set of
+// preference names is used to partition the preferences.
+class SegregatedPrefStore : public PersistentPrefStore {
+ public:
+  // Creates an instance that delegates to |selected_pref_store| for the
+  // preferences named in |selected_pref_names| and to |default_pref_store|
+  // for all others. If an unselected preference is present in
+  // |selected_pref_store| (i.e. because it was previously selected) it will
+  // be migrated back to |default_pref_store| upon access via a non-const
+  // method.
+  // |on_initialization| will be invoked when both stores have been initialized,
+  // before observers of the combined store are notified.

[gab, 2014/04/01 18:55:06]

What's "the combined store", this SegregatedPrefStore?

+  SegregatedPrefStore(
+      const scoped_refptr<PersistentPrefStore>& default_pref_store,
+      const scoped_refptr<PersistentPrefStore>& selected_pref_store,
+      const std::set<std::string>& selected_pref_names,
+      const base::Closure& on_initialization);
+
+  // PrefStore implementation
+  virtual void AddObserver(Observer* observer) OVERRIDE;
+  virtual void RemoveObserver(Observer* observer) OVERRIDE;
+  virtual bool HasObservers() const OVERRIDE;
+  virtual bool IsInitializationComplete() const OVERRIDE;
+  virtual bool GetValue(const std::string& key,
+                        const base::Value** result) const OVERRIDE;
+
+  // WriteablePrefStore implementation
+  virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE;
+  virtual void RemoveValue(const std::string& key) OVERRIDE;
+
+  // PersistentPrefStore implementation
+  virtual bool GetMutableValue(const std::string& key,
+                               base::Value** result) OVERRIDE;
+  virtual void ReportValueChanged(const std::string& key) OVERRIDE;
+  virtual void SetValueSilently(const std::string& key,
+                                base::Value* value) OVERRIDE;
+  virtual bool ReadOnly() const OVERRIDE;
+  virtual PrefReadError GetReadError() const OVERRIDE;
+  virtual PrefReadError ReadPrefs() OVERRIDE;
+  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) OVERRIDE;
+  virtual void CommitPendingWrite() OVERRIDE;
+
+ private:
+  // Aggregates events from the underlying stores and synthesizes external
+  // events via |on_initialization|, |read_error_delegate_|, and |observers_|.
+  class AggregatingObserver : public PrefStore::Observer {
+   public:
+    explicit AggregatingObserver(SegregatedPrefStore* outer);
+
+    // PrefStore::Observer implementation
+    virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
+    virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
+
+   private:
+    SegregatedPrefStore* outer_;
+    int failed_sub_initializations_;
+    int successful_sub_initializations_;
+
+    DISALLOW_COPY_AND_ASSIGN(AggregatingObserver);
+  };
+
+  virtual ~SegregatedPrefStore();
+
+  // Returns |selected_pref_store| if |key| is selected or a value is present
+  // in |selected_pref_store|. This could happen if |key| was previously
+  // selected.
+  const PersistentPrefStore* StoreForKey(const std::string& key) const;
+
+  // Returns |selected_pref_store| if |key| is selected. If |key| is
+  // unselected but has a value in |selected_pref_store|, moves the value to
+  // |default_pref_store| before returning |default_pref_store|.
+  PersistentPrefStore* StoreForKey(const std::string& key);
+
+  scoped_refptr<PersistentPrefStore> default_pref_store_;
+  scoped_refptr<PersistentPrefStore> selected_pref_store_;
+  std::set<std::string> selected_preference_names_;
+  base::Closure on_initialization_;
+
+  scoped_ptr<PersistentPrefStore::ReadErrorDelegate> read_error_delegate_;
+  ObserverList<PrefStore::Observer, true> observers_;
+  AggregatingObserver aggregating_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(SegregatedPrefStore);
+};
+
+#endif  // CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_