1 // Copyright (c) 2012 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_BOOKMARK_MODEL_ASSOCIATOR_H_ 6 #define CHROME_BROWSER_SYNC_GLUE_BOOKMARK_MODEL_ASSOCIATOR_H_ 7 8 #include <map> 9 #include <set> 10 #include <string> 11 12 #include "base/basictypes.h" 13 #include "base/compiler_specific.h" 14 #include "base/memory/weak_ptr.h" 15 #include "components/sync_driver/data_type_controller.h" 16 #include "components/sync_driver/data_type_error_handler.h" 17 #include "components/sync_driver/model_associator.h" 18 #include "sync/internal_api/public/util/unrecoverable_error_handler.h" 19 20 class BookmarkModel; 21 class BookmarkNode; 22 class Profile; 23 24 namespace syncer { 25 class BaseNode; 26 class BaseTransaction; 27 struct UserShare; 28 } 29 30 namespace browser_sync { 31 32 // Contains all model association related logic: 33 // * Algorithm to associate bookmark model and sync model. 34 // * Methods to get a bookmark node for a given sync node and vice versa. 35 // * Persisting model associations and loading them back. 36 class BookmarkModelAssociator 37 : public sync_driver::PerDataTypeAssociatorInterface<BookmarkNode, int64> { 38 public: model_type()39 static syncer::ModelType model_type() { return syncer::BOOKMARKS; } 40 // |expect_mobile_bookmarks_folder| controls whether or not we 41 // expect the mobile bookmarks permanent folder to be created. 42 // Should be set to true only by mobile clients. 43 BookmarkModelAssociator( 44 BookmarkModel* bookmark_model, 45 Profile* profile_, 46 syncer::UserShare* user_share, 47 sync_driver::DataTypeErrorHandler* unrecoverable_error_handler, 48 bool expect_mobile_bookmarks_folder); 49 virtual ~BookmarkModelAssociator(); 50 51 // Updates the visibility of the permanents node in the BookmarkModel. 52 void UpdatePermanentNodeVisibility(); 53 54 // AssociatorInterface implementation. 55 // 56 // AssociateModels iterates through both the sync and the browser 57 // bookmark model, looking for matched pairs of items. For any pairs it 58 // finds, it will call AssociateSyncID. For any unmatched items, 59 // MergeAndAssociateModels will try to repair the match, e.g. by adding a new 60 // node. After successful completion, the models should be identical and 61 // corresponding. Returns true on success. On failure of this step, we 62 // should abort the sync operation and report an error to the user. 63 virtual syncer::SyncError AssociateModels( 64 syncer::SyncMergeResult* local_merge_result, 65 syncer::SyncMergeResult* syncer_merge_result) OVERRIDE; 66 67 virtual syncer::SyncError DisassociateModels() OVERRIDE; 68 69 // The has_nodes out param is true if the sync model has nodes other 70 // than the permanent tagged nodes. 71 virtual bool SyncModelHasUserCreatedNodes(bool* has_nodes) OVERRIDE; 72 73 // Returns sync id for the given bookmark node id. 74 // Returns syncer::kInvalidId if the sync node is not found for the given 75 // bookmark node id. 76 virtual int64 GetSyncIdFromChromeId(const int64& node_id) OVERRIDE; 77 78 // Returns the bookmark node for the given sync id. 79 // Returns NULL if no bookmark node is found for the given sync id. 80 virtual const BookmarkNode* GetChromeNodeFromSyncId(int64 sync_id) OVERRIDE; 81 82 // Initializes the given sync node from the given bookmark node id. 83 // Returns false if no sync node was found for the given bookmark node id or 84 // if the initialization of sync node fails. 85 virtual bool InitSyncNodeFromChromeId( 86 const int64& node_id, 87 syncer::BaseNode* sync_node) OVERRIDE; 88 89 // Associates the given bookmark node with the given sync id. 90 virtual void Associate(const BookmarkNode* node, int64 sync_id) OVERRIDE; 91 // Remove the association that corresponds to the given sync id. 92 virtual void Disassociate(int64 sync_id) OVERRIDE; 93 AbortAssociation()94 virtual void AbortAssociation() OVERRIDE { 95 // No implementation needed, this associator runs on the main 96 // thread. 97 } 98 99 // See ModelAssociator interface. 100 virtual bool CryptoReadyIfNecessary() OVERRIDE; 101 102 protected: 103 // Stores the id of the node with the given tag in |sync_id|. 104 // Returns of that node was found successfully. 105 // Tests override this. 106 virtual bool GetSyncIdForTaggedNode(const std::string& tag, int64* sync_id); 107 108 private: 109 typedef std::map<int64, int64> BookmarkIdToSyncIdMap; 110 typedef std::map<int64, const BookmarkNode*> SyncIdToBookmarkNodeMap; 111 typedef std::set<int64> DirtyAssociationsSyncIds; 112 113 // Posts a task to persist dirty associations. 114 void PostPersistAssociationsTask(); 115 // Persists all dirty associations. 116 void PersistAssociations(); 117 118 // Matches up the bookmark model and the sync model to build model 119 // associations. 120 syncer::SyncError BuildAssociations( 121 syncer::SyncMergeResult* local_merge_result, 122 syncer::SyncMergeResult* syncer_merge_result); 123 124 // Removes bookmark nodes whose corresponding sync nodes have been deleted 125 // according to sync delete journals. Return number of deleted bookmarks. 126 int64 ApplyDeletesFromSyncJournal(syncer::BaseTransaction* trans); 127 128 // Associate a top-level node of the bookmark model with a permanent node in 129 // the sync domain. Such permanent nodes are identified by a tag that is 130 // well known to the server and the client, and is unique within a particular 131 // user's share. For example, "other_bookmarks" is the tag for the Other 132 // Bookmarks folder. The sync nodes are server-created. 133 // Returns true on success, false if association failed. 134 bool AssociateTaggedPermanentNode( 135 const BookmarkNode* permanent_node, 136 const std::string& tag) WARN_UNUSED_RESULT; 137 138 // Compare the properties of a pair of nodes from either domain. 139 bool NodesMatch(const BookmarkNode* bookmark, 140 const syncer::BaseNode* sync_node) const; 141 142 // Check whether bookmark model and sync model are synced by comparing 143 // their transaction versions. 144 // Returns a PERSISTENCE_ERROR if a transaction mismatch was detected where 145 // the native model has a newer transaction verison. 146 syncer::SyncError CheckModelSyncState( 147 syncer::SyncMergeResult* local_merge_result, 148 syncer::SyncMergeResult* syncer_merge_result) const; 149 150 BookmarkModel* bookmark_model_; 151 Profile* profile_; 152 syncer::UserShare* user_share_; 153 sync_driver::DataTypeErrorHandler* unrecoverable_error_handler_; 154 const bool expect_mobile_bookmarks_folder_; 155 BookmarkIdToSyncIdMap id_map_; 156 SyncIdToBookmarkNodeMap id_map_inverse_; 157 // Stores sync ids for dirty associations. 158 DirtyAssociationsSyncIds dirty_associations_sync_ids_; 159 160 // Used to post PersistAssociation tasks to the current message loop and 161 // guarantees no invocations can occur if |this| has been deleted. (This 162 // allows this class to be non-refcounted). 163 base::WeakPtrFactory<BookmarkModelAssociator> weak_factory_; 164 165 DISALLOW_COPY_AND_ASSIGN(BookmarkModelAssociator); 166 }; 167 168 } // namespace browser_sync 169 170 #endif // CHROME_BROWSER_SYNC_GLUE_BOOKMARK_MODEL_ASSOCIATOR_H_ 171