1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
// Copyright 2017 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 COMPONENTS_SYNC_BOOKMARKS_BOOKMARK_MODEL_TYPE_PROCESSOR_H_
#define COMPONENTS_SYNC_BOOKMARKS_BOOKMARK_MODEL_TYPE_PROCESSOR_H_
#include <memory>
#include <string>
#include "base/callback.h"
#include "base/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/sequence_checker.h"
#include "components/sync/engine/model_type_processor.h"
#include "components/sync/model/model_type_controller_delegate.h"
#include "components/sync_bookmarks/synced_bookmark_tracker.h"
class BookmarkUndoService;
namespace bookmarks {
class BookmarkModel;
}
namespace favicon {
class FaviconService;
}
namespace sync_bookmarks {
class BookmarkModelObserverImpl;
class BookmarkModelTypeProcessor : public syncer::ModelTypeProcessor,
public syncer::ModelTypeControllerDelegate {
public:
// |bookmark_undo_service| must not be nullptr and must outlive this object.
explicit BookmarkModelTypeProcessor(
BookmarkUndoService* bookmark_undo_service);
BookmarkModelTypeProcessor(const BookmarkModelTypeProcessor&) = delete;
BookmarkModelTypeProcessor& operator=(const BookmarkModelTypeProcessor&) =
delete;
~BookmarkModelTypeProcessor() override;
// ModelTypeProcessor implementation.
void ConnectSync(std::unique_ptr<syncer::CommitQueue> worker) override;
void DisconnectSync() override;
void GetLocalChanges(size_t max_entries,
GetLocalChangesCallback callback) override;
void OnCommitCompleted(
const sync_pb::ModelTypeState& type_state,
const syncer::CommitResponseDataList& committed_response_list,
const syncer::FailedCommitResponseDataList& error_response_list) override;
void OnUpdateReceived(const sync_pb::ModelTypeState& type_state,
syncer::UpdateResponseDataList updates) override;
// ModelTypeControllerDelegate implementation.
void OnSyncStarting(const syncer::DataTypeActivationRequest& request,
StartCallback start_callback) override;
void OnSyncStopping(syncer::SyncStopMetadataFate metadata_fate) override;
void GetAllNodesForDebugging(AllNodesCallback callback) override;
void GetTypeEntitiesCountForDebugging(
base::OnceCallback<void(const syncer::TypeEntitiesCount&)> callback)
const override;
void RecordMemoryUsageAndCountsHistograms() override;
// Encodes all sync metadata into a string, representing a state that can be
// restored via ModelReadyToSync() below.
std::string EncodeSyncMetadata() const;
// It mainly decodes a BookmarkModelMetadata proto serialized in
// |metadata_str|, and uses it to fill in the tracker and the model type state
// objects. |model| must not be null and must outlive this object. It is used
// to the retrieve the local node ids, and is stored in the processor to be
// used for further model operations. |schedule_save_closure| is a repeating
// closure used to schedule a save of the bookmark model together with the
// metadata.
void ModelReadyToSync(const std::string& metadata_str,
const base::RepeatingClosure& schedule_save_closure,
bookmarks::BookmarkModel* model);
// Sets the favicon service used when processing remote updates. It must be
// called before the processor is ready to receive remote updates, and hence
// before OnSyncStarting() is called. |favicon_service| must not be null.
void SetFaviconService(favicon::FaviconService* favicon_service);
// Returns the estimate of dynamically allocated memory in bytes.
size_t EstimateMemoryUsage() const;
const SyncedBookmarkTracker* GetTrackerForTest() const;
bool IsConnectedForTest() const;
base::WeakPtr<syncer::ModelTypeControllerDelegate> GetWeakPtr();
private:
SEQUENCE_CHECKER(sequence_checker_);
// If preconditions are met, inform sync that we are ready to connect.
void ConnectIfReady();
// Nudges worker if there are any local entities to be committed. Should only
// be called after initial sync is done and processor is tracking sync
// entities.
void NudgeForCommitIfNeeded();
// Performs the required clean up when bookmark model is being deleted.
void OnBookmarkModelBeingDeleted();
// Process specifically calls to OnUpdateReceived() that correspond to the
// initial merge of bookmarks (e.g. was just enabled).
void OnInitialUpdateReceived(const sync_pb::ModelTypeState& type_state,
syncer::UpdateResponseDataList updates);
// Instantiates the required objects to track metadata and starts observing
// changes from the bookmark model.
void StartTrackingMetadata();
void StopTrackingMetadata();
// Creates a DictionaryValue for local and remote debugging information about
// |node| and appends it to |all_nodes|. It does the same for child nodes
// recursively. |index| is the index of |node| within its parent. |index|
// could computed from |node|, however it's much cheaper to pass from outside
// since we iterate over child nodes already in the calling sites.
void AppendNodeAndChildrenForDebugging(const bookmarks::BookmarkNode* node,
int index,
base::Value::List* all_nodes) const;
// Stores the start callback in between OnSyncStarting() and
// ModelReadyToSync().
StartCallback start_callback_;
// The bookmark model we are processing local changes from and forwarding
// remote changes to. It is set during ModelReadyToSync(), which is called
// during startup, as part of the bookmark-loading process.
raw_ptr<bookmarks::BookmarkModel> bookmark_model_ = nullptr;
// Used to when processing remote updates to apply favicon information. It's
// not set at start up because it's only avialable after the bookmark model
// has been loaded.
raw_ptr<favicon::FaviconService> favicon_service_ = nullptr;
// Used to suspend bookmark undo when processing remote changes.
const raw_ptr<BookmarkUndoService> bookmark_undo_service_;
// The callback used to schedule the persistence of bookmark model as well as
// the metadata to a file during which latest metadata should also be pulled
// via EncodeSyncMetadata. Processor should invoke it upon changes in the
// metadata that don't imply changes in the model itself. Persisting updates
// that imply model changes is the model's responsibility.
base::RepeatingClosure schedule_save_closure_;
// Reference to the CommitQueue.
//
// The interface hides the posting of tasks across threads as well as the
// CommitQueue's implementation. Both of these features are
// useful in tests.
std::unique_ptr<syncer::CommitQueue> worker_;
// Keeps the mapping between server ids and bookmarks nodes together with sync
// metadata. It is constructed and set during ModelReadyToSync(), if the
// loaded bookmarks JSON contained previous sync metadata, or upon completion
// of initial sync, which is called during startup, as part of the
// bookmark-loading process.
std::unique_ptr<SyncedBookmarkTracker> bookmark_tracker_;
// GUID string that identifies the sync client and is received from the sync
// engine.
std::string cache_guid_;
syncer::ModelErrorHandler error_handler_;
std::unique_ptr<BookmarkModelObserverImpl> bookmark_model_observer_;
// WeakPtrFactory for this processor for ModelTypeController.
base::WeakPtrFactory<BookmarkModelTypeProcessor>
weak_ptr_factory_for_controller_{this};
// WeakPtrFactory for this processor which will be sent to sync thread.
base::WeakPtrFactory<BookmarkModelTypeProcessor> weak_ptr_factory_for_worker_{
this};
};
} // namespace sync_bookmarks
#endif // COMPONENTS_SYNC_BOOKMARKS_BOOKMARK_MODEL_TYPE_PROCESSOR_H_
|
