Home | History | Annotate | Download | only in tracked 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_
      6 #define CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_
      7 
      8 #include <set>
      9 #include <string>
     10 
     11 #include "base/compiler_specific.h"
     12 #include "base/macros.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/memory/scoped_ptr.h"
     15 #include "base/observer_list.h"
     16 #include "base/prefs/persistent_pref_store.h"
     17 
     18 // Provides a unified PersistentPrefStore implementation that splits its storage
     19 // and retrieval between two underlying PersistentPrefStore instances: a set of
     20 // preference names is used to partition the preferences.
     21 //
     22 // Combines properties of the two stores as follows:
     23 //   * The unified read error will be:
     24 //                           Selected Store Error
     25 //    Default Store Error | NO_ERROR      | NO_FILE       | other selected |
     26 //               NO_ERROR | NO_ERROR      | NO_ERROR      | other selected |
     27 //               NO_FILE  | NO_FILE       | NO_FILE       | NO_FILE        |
     28 //          other default | other default | other default | other default  |
     29 //   * The unified initialization success, initialization completion, and
     30 //     read-only state are the boolean OR of the underlying stores' properties.
     31 class SegregatedPrefStore : public PersistentPrefStore {
     32  public:
     33   // Creates an instance that delegates to |selected_pref_store| for the
     34   // preferences named in |selected_pref_names| and to |default_pref_store|
     35   // for all others. If an unselected preference is present in
     36   // |selected_pref_store| (i.e. because it was previously selected) it will
     37   // be migrated back to |default_pref_store| upon access via a non-const
     38   // method.
     39   // |on_initialization| will be invoked when both stores have been initialized,
     40   // before observers of the SegregatedPrefStore store are notified.
     41   SegregatedPrefStore(
     42       const scoped_refptr<PersistentPrefStore>& default_pref_store,
     43       const scoped_refptr<PersistentPrefStore>& selected_pref_store,
     44       const std::set<std::string>& selected_pref_names);
     45 
     46   // PrefStore implementation
     47   virtual void AddObserver(Observer* observer) OVERRIDE;
     48   virtual void RemoveObserver(Observer* observer) OVERRIDE;
     49   virtual bool HasObservers() const OVERRIDE;
     50   virtual bool IsInitializationComplete() const OVERRIDE;
     51   virtual bool GetValue(const std::string& key,
     52                         const base::Value** result) const OVERRIDE;
     53 
     54   // WriteablePrefStore implementation
     55   virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE;
     56   virtual void RemoveValue(const std::string& key) OVERRIDE;
     57 
     58   // PersistentPrefStore implementation
     59   virtual bool GetMutableValue(const std::string& key,
     60                                base::Value** result) OVERRIDE;
     61   virtual void ReportValueChanged(const std::string& key) OVERRIDE;
     62   virtual void SetValueSilently(const std::string& key,
     63                                 base::Value* value) OVERRIDE;
     64   virtual bool ReadOnly() const OVERRIDE;
     65   virtual PrefReadError GetReadError() const OVERRIDE;
     66   virtual PrefReadError ReadPrefs() OVERRIDE;
     67   virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) OVERRIDE;
     68   virtual void CommitPendingWrite() OVERRIDE;
     69 
     70  private:
     71   // Aggregates events from the underlying stores and synthesizes external
     72   // events via |on_initialization|, |read_error_delegate_|, and |observers_|.
     73   class AggregatingObserver : public PrefStore::Observer {
     74    public:
     75     explicit AggregatingObserver(SegregatedPrefStore* outer);
     76 
     77     // PrefStore::Observer implementation
     78     virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
     79     virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
     80 
     81    private:
     82     SegregatedPrefStore* outer_;
     83     int failed_sub_initializations_;
     84     int successful_sub_initializations_;
     85 
     86     DISALLOW_COPY_AND_ASSIGN(AggregatingObserver);
     87   };
     88 
     89   virtual ~SegregatedPrefStore();
     90 
     91   // Returns |selected_pref_store| if |key| is selected and |default_pref_store|
     92   // otherwise.
     93   PersistentPrefStore* StoreForKey(const std::string& key);
     94   const PersistentPrefStore* StoreForKey(const std::string& key) const;
     95 
     96   scoped_refptr<PersistentPrefStore> default_pref_store_;
     97   scoped_refptr<PersistentPrefStore> selected_pref_store_;
     98   std::set<std::string> selected_preference_names_;
     99 
    100   scoped_ptr<PersistentPrefStore::ReadErrorDelegate> read_error_delegate_;
    101   ObserverList<PrefStore::Observer, true> observers_;
    102   AggregatingObserver aggregating_observer_;
    103 
    104   DISALLOW_COPY_AND_ASSIGN(SegregatedPrefStore);
    105 };
    106 
    107 #endif  // CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_
    108