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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
// Copyright (c) 2012 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 CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
#define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
#include <string>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "base/threading/thread.h"
#include "components/sync_driver/backend_data_type_configurer.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/configure_reason.h"
#include "sync/internal_api/public/sessions/sync_session_snapshot.h"
#include "sync/internal_api/public/shutdown_reason.h"
#include "sync/internal_api/public/sync_context_proxy.h"
#include "sync/internal_api/public/sync_manager.h"
#include "sync/internal_api/public/sync_manager_factory.h"
#include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
#include "sync/internal_api/public/util/unrecoverable_error_handler.h"
#include "sync/internal_api/public/util/weak_handle.h"
class GURL;
namespace base {
class MessageLoop;
}
namespace syncer {
class NetworkResources;
class SyncManagerFactory;
}
namespace sync_driver {
class ChangeProcessor;
class SyncFrontend;
}
namespace browser_sync {
// An API to "host" the top level SyncAPI element.
//
// This class handles dispatch of potentially blocking calls to appropriate
// threads and ensures that the SyncFrontend is only accessed on the UI loop.
class SyncBackendHost : public sync_driver::BackendDataTypeConfigurer {
public:
typedef syncer::SyncStatus Status;
// Stubs used by implementing classes.
SyncBackendHost();
virtual ~SyncBackendHost();
// Called on the frontend's thread to kick off asynchronous initialization.
// Optionally deletes the "Sync Data" folder during init in order to make
// sure we're starting fresh.
//
// |report_unrecoverable_error_function| can be NULL. Note:
// |unrecoverable_error_handler| may be invoked from any thread.
virtual void Initialize(
sync_driver::SyncFrontend* frontend,
scoped_ptr<base::Thread> sync_thread,
const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
const GURL& service_url,
const syncer::SyncCredentials& credentials,
bool delete_sync_data_folder,
scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler,
syncer::ReportUnrecoverableErrorFunction
report_unrecoverable_error_function,
syncer::NetworkResources* network_resources) = 0;
// Called on the frontend's thread to update SyncCredentials.
virtual void UpdateCredentials(
const syncer::SyncCredentials& credentials) = 0;
// This starts the SyncerThread running a Syncer object to communicate with
// sync servers. Until this is called, no changes will leave or enter this
// browser from the cloud / sync servers.
// Called on |frontend_loop_|.
virtual void StartSyncingWithServer() = 0;
// Called on |frontend_loop_| to asynchronously set a new passphrase for
// encryption. Note that it is an error to call SetEncryptionPassphrase under
// the following circumstances:
// - An explicit passphrase has already been set
// - |is_explicit| is true and we have pending keys.
// When |is_explicit| is false, a couple of things could happen:
// - If there are pending keys, we try to decrypt them. If decryption works,
// this acts like a call to SetDecryptionPassphrase. If not, the GAIA
// passphrase passed in is cached so we can re-encrypt with it in future.
// - If there are no pending keys, data is encrypted with |passphrase| (this
// is a no-op if data was already encrypted with |passphrase|.)
virtual void SetEncryptionPassphrase(
const std::string& passphrase,
bool is_explicit) = 0;
// Called on |frontend_loop_| to use the provided passphrase to asynchronously
// attempt decryption. Returns false immediately if the passphrase could not
// be used to decrypt a locally cached copy of encrypted keys; returns true
// otherwise. If new encrypted keys arrive during the asynchronous call,
// OnPassphraseRequired may be triggered at a later time. It is an error to
// call this when there are no pending keys.
virtual bool SetDecryptionPassphrase(const std::string& passphrase)
WARN_UNUSED_RESULT = 0;
// Called on |frontend_loop_| to kick off shutdown procedure. Attempts to cut
// short any long-lived or blocking sync thread tasks so that the shutdown on
// sync thread task that we're about to post won't have to wait very long.
virtual void StopSyncingForShutdown() = 0;
// Called on |frontend_loop_| to kick off shutdown.
// See the implementation and Core::DoShutdown for details.
// Must be called *after* StopSyncingForShutdown.
// For any reason other than BROWSER_SHUTDOWN, caller should claim sync
// thread because:
// * during browser shutdown sync thread is not claimed to avoid blocking
// browser shutdown on sync shutdown.
// * otherwise sync thread is claimed so that if sync backend is recreated
// later, initialization of new backend is serialized on previous sync
// thread after cleanup of previous backend to avoid old/new backends
// interfere with each other.
virtual scoped_ptr<base::Thread> Shutdown(syncer::ShutdownReason reason) = 0;
// Removes all current registrations from the backend on the
// InvalidationService.
virtual void UnregisterInvalidationIds() = 0;
// Changes the set of data types that are currently being synced.
// The ready_task will be run when configuration is done with the
// set of all types that failed configuration (i.e., if its argument
// is non-empty, then an error was encountered).
virtual void ConfigureDataTypes(
syncer::ConfigureReason reason,
const DataTypeConfigStateMap& config_state_map,
const base::Callback<void(syncer::ModelTypeSet,
syncer::ModelTypeSet)>& ready_task,
const base::Callback<void()>& retry_callback) OVERRIDE = 0;
// Turns on encryption of all present and future sync data.
virtual void EnableEncryptEverything() = 0;
// Called on |frontend_loop_| to obtain a handle to the UserShare needed for
// creating transactions. Should not be called before we signal
// initialization is complete with OnBackendInitialized().
virtual syncer::UserShare* GetUserShare() const = 0;
// Called on |frontend_loop_| to obtain a handle to the SyncContext needed by
// the non-blocking sync types to communicate with the server.
//
// Should be called only when the backend is initialized.
virtual scoped_ptr<syncer::SyncContextProxy> GetSyncContextProxy() = 0;
// Called from any thread to obtain current status information in detailed or
// summarized form.
virtual Status GetDetailedStatus() = 0;
virtual syncer::sessions::SyncSessionSnapshot
GetLastSessionSnapshot() const = 0;
// Determines if the underlying sync engine has made any local changes to
// items that have not yet been synced with the server.
// ONLY CALL THIS IF OnInitializationComplete was called!
virtual bool HasUnsyncedItems() const = 0;
// Whether or not we are syncing encryption keys.
virtual bool IsNigoriEnabled() const = 0;
// Returns the type of passphrase being used to encrypt data. See
// sync_encryption_handler.h.
virtual syncer::PassphraseType GetPassphraseType() const = 0;
// If an explicit passphrase is in use, returns the time at which that
// passphrase was set (if available).
virtual base::Time GetExplicitPassphraseTime() const = 0;
// True if the cryptographer has any keys available to attempt decryption.
// Could mean we've downloaded and loaded Nigori objects, or we bootstrapped
// using a token previously received.
virtual bool IsCryptographerReady(
const syncer::BaseTransaction* trans) const = 0;
virtual void GetModelSafeRoutingInfo(
syncer::ModelSafeRoutingInfo* out) const = 0;
// Requests that the backend forward to the fronent any protocol events in
// its buffer and begin forwarding automatically from now on. Repeated calls
// to this function may result in the same events being emitted several
// times.
virtual void RequestBufferedProtocolEventsAndEnableForwarding() = 0;
// Disables protocol event forwarding.
virtual void DisableProtocolEventForwarding() = 0;
// Returns a ListValue representing all nodes for the specified types through
// |callback| on this thread.
virtual void GetAllNodesForTypes(
syncer::ModelTypeSet types,
base::Callback<void(const std::vector<syncer::ModelType>&,
ScopedVector<base::ListValue>)> type) = 0;
// Enables the sending of directory type debug counters. Also, for every
// time it is called, it makes an explicit request that updates to an update
// for all counters be emitted.
virtual void EnableDirectoryTypeDebugInfoForwarding() = 0;
// Disables the sending of directory type debug counters.
virtual void DisableDirectoryTypeDebugInfoForwarding() = 0;
virtual base::MessageLoop* GetSyncLoopForTesting() = 0;
DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
};
} // namespace browser_sync
#endif // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
|
