• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2011 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_SYNC_GLUE_PREFERENCE_MODEL_ASSOCIATOR_H_
6 #define CHROME_BROWSER_SYNC_GLUE_PREFERENCE_MODEL_ASSOCIATOR_H_
7 #pragma once
8 
9 #include <map>
10 #include <set>
11 #include <string>
12 
13 #include "base/basictypes.h"
14 #include "chrome/browser/prefs/pref_service.h"
15 #include "chrome/browser/sync/glue/model_associator.h"
16 #include "chrome/browser/sync/unrecoverable_error_handler.h"
17 
18 class ProfileSyncService;
19 class Value;
20 
21 namespace sync_api {
22 class WriteNode;
23 class WriteTransaction;
24 }
25 
26 namespace browser_sync {
27 
28 class PreferenceChangeProcessor;
29 
30 static const char kPreferencesTag[] = "google_chrome_preferences";
31 
32 // Contains all model association related logic:
33 // * Algorithm to associate preferences model and sync model.
34 class PreferenceModelAssociator
35     : public PerDataTypeAssociatorInterface<PrefService::Preference,
36                                             std::string> {
37  public:
model_type()38   static syncable::ModelType model_type() { return syncable::PREFERENCES; }
39   explicit PreferenceModelAssociator(ProfileSyncService* sync_service);
40   virtual ~PreferenceModelAssociator();
41 
42   // Returns the list of preference names that should be monitored for
43   // changes.  Only preferences that are registered will be in this
44   // list.
synced_preferences()45   const std::set<std::string>& synced_preferences() {
46     return synced_preferences_;
47   }
48 
49   // Create an association for a given preference. A sync node is created if
50   // necessary and the value is read from or written to the node as appropriate.
51   bool InitPrefNodeAndAssociate(sync_api::WriteTransaction* trans,
52                                 const sync_api::BaseNode& root,
53                                 const PrefService::Preference* pref);
54 
55   // PerDataTypeAssociatorInterface implementation.
56   //
57   // Iterates through the sync model looking for matched pairs of items.
58   virtual bool AssociateModels();
59 
60   // Clears all associations.
61   virtual bool DisassociateModels();
62 
63   // Returns whether the sync model has nodes other than the permanent tagged
64   // nodes.
65   virtual bool SyncModelHasUserCreatedNodes(bool* has_nodes);
66 
AbortAssociation()67   virtual void AbortAssociation() {
68     // No implementation needed, this associator runs on the main
69     // thread.
70   }
71 
72   // See ModelAssociator interface.
73   virtual bool CryptoReadyIfNecessary();
74 
75   // Not implemented.
76   virtual const PrefService::Preference* GetChromeNodeFromSyncId(int64 sync_id);
77 
78   // Not implemented.
79   virtual bool InitSyncNodeFromChromeId(const std::string& node_id,
80                                         sync_api::BaseNode* sync_node);
81 
82   // Returns the sync id for the given preference name, or sync_api::kInvalidId
83   // if the preference name is not associated to any sync id.
84   virtual int64 GetSyncIdFromChromeId(const std::string& node_id);
85 
86   // Associates the given preference name with the given sync id.
87   virtual void Associate(const PrefService::Preference* node, int64 sync_id);
88 
89   // Remove the association that corresponds to the given sync id.
90   virtual void Disassociate(int64 sync_id);
91 
92   // Returns whether a node with the given permanent tag was found and update
93   // |sync_id| with that node's id.
94   virtual bool GetSyncIdForTaggedNode(const std::string& tag, int64* sync_id);
95 
96   // Merges the value of local_pref into the supplied server_value and
97   // returns the result (caller takes ownership).  If there is a
98   // conflict, the server value always takes precedence.  Note that
99   // only certain preferences will actually be merged, all others will
100   // return a copy of the server value.  See the method's
101   // implementation for details.
102   static Value* MergePreference(const PrefService::Preference& local_pref,
103                                 const Value& server_value);
104 
105   // Writes the value of pref into the specified node.  Returns true
106   // upon success.
107   static bool WritePreferenceToNode(const std::string& name,
108                                     const Value& value,
109                                     sync_api::WriteNode* node);
110 
111   // Perform any additional operations that need to happen after a preference
112   // has been updated.
113   void AfterUpdateOperations(const std::string& pref_name);
114 
115  private:
116   typedef std::map<std::string, int64> PreferenceNameToSyncIdMap;
117   typedef std::map<int64, std::string> SyncIdToPreferenceNameMap;
118 
119   static Value* MergeListValues(const Value& from_value, const Value& to_value);
120   static Value* MergeDictionaryValues(const Value& from_value,
121                                       const Value& to_value);
122 
123   ProfileSyncService* sync_service_;
124   std::set<std::string> synced_preferences_;
125   int64 preferences_node_id_;
126 
127   PreferenceNameToSyncIdMap id_map_;
128   SyncIdToPreferenceNameMap id_map_inverse_;
129 
130   DISALLOW_COPY_AND_ASSIGN(PreferenceModelAssociator);
131 };
132 
133 }  // namespace browser_sync
134 
135 #endif  // CHROME_BROWSER_SYNC_GLUE_PREFERENCE_MODEL_ASSOCIATOR_H_
136