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.
31class 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