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
|
// Copyright 2014 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 SYNC_ENGINE_MODEL_TYPE_REGISTRY_H_
#define SYNC_ENGINE_MODEL_TYPE_REGISTRY_H_
#include <map>
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "base/memory/weak_ptr.h"
#include "sync/base/sync_export.h"
#include "sync/engine/nudge_handler.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/engine/model_safe_worker.h"
#include "sync/internal_api/public/non_blocking_sync_common.h"
#include "sync/internal_api/public/sessions/type_debug_info_observer.h"
#include "sync/internal_api/public/sync_context.h"
#include "sync/internal_api/public/sync_encryption_handler.h"
namespace syncer_v2 {
struct DataTypeState;
}
namespace syncer {
namespace syncable {
class Directory;
} // namespace syncable
class CommitContributor;
class DirectoryCommitContributor;
class DirectoryUpdateHandler;
class DirectoryTypeDebugInfoEmitter;
class ModelTypeSyncWorkerImpl;
class ModelTypeSyncProxyImpl;
class UpdateHandler;
typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap;
typedef std::map<ModelType, CommitContributor*> CommitContributorMap;
typedef std::map<ModelType, DirectoryTypeDebugInfoEmitter*>
DirectoryTypeDebugInfoEmitterMap;
// Keeps track of the sets of active update handlers and commit contributors.
class SYNC_EXPORT_PRIVATE ModelTypeRegistry
: public syncer_v2::SyncContext,
public SyncEncryptionHandler::Observer {
public:
// Constructs a ModelTypeRegistry that supports directory types.
ModelTypeRegistry(const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
syncable::Directory* directory,
NudgeHandler* nudge_handler);
~ModelTypeRegistry() override;
// Sets the set of enabled types.
void SetEnabledDirectoryTypes(const ModelSafeRoutingInfo& routing_info);
// Enables an off-thread type for syncing. Connects the given proxy
// and its task_runner to the newly created worker.
//
// Expects that the proxy's ModelType is not currently enabled.
void ConnectSyncTypeToWorker(
syncer::ModelType type,
const syncer_v2::DataTypeState& data_type_state,
const syncer_v2::UpdateResponseDataList& saved_pending_updates,
const scoped_refptr<base::SequencedTaskRunner>& type_task_runner,
const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy) override;
// Disables the syncing of an off-thread type.
//
// Expects that the type is currently enabled.
// Deletes the worker associated with the type.
void DisconnectSyncWorker(syncer::ModelType type) override;
// Implementation of SyncEncryptionHandler::Observer.
void OnPassphraseRequired(
PassphraseRequiredReason reason,
const sync_pb::EncryptedData& pending_keys) override;
void OnPassphraseAccepted() override;
void OnBootstrapTokenUpdated(const std::string& bootstrap_token,
BootstrapTokenType type) override;
void OnEncryptedTypesChanged(ModelTypeSet encrypted_types,
bool encrypt_everything) override;
void OnEncryptionComplete() override;
void OnCryptographerStateChanged(Cryptographer* cryptographer) override;
void OnPassphraseTypeChanged(PassphraseType type,
base::Time passphrase_time) override;
void OnLocalSetPassphraseEncryption(
const SyncEncryptionHandler::NigoriState& nigori_state) override;
// Gets the set of enabled types.
ModelTypeSet GetEnabledTypes() const;
// Simple getters.
UpdateHandlerMap* update_handler_map();
CommitContributorMap* commit_contributor_map();
DirectoryTypeDebugInfoEmitterMap* directory_type_debug_info_emitter_map();
void RegisterDirectoryTypeDebugInfoObserver(
syncer::TypeDebugInfoObserver* observer);
void UnregisterDirectoryTypeDebugInfoObserver(
syncer::TypeDebugInfoObserver* observer);
bool HasDirectoryTypeDebugInfoObserver(
const syncer::TypeDebugInfoObserver* observer) const;
void RequestEmitDebugInfo();
base::WeakPtr<SyncContext> AsWeakPtr();
private:
void OnEncryptionStateChanged();
ModelTypeSet GetEnabledNonBlockingTypes() const;
ModelTypeSet GetEnabledDirectoryTypes() const;
// Sets of handlers and contributors.
ScopedVector<DirectoryCommitContributor> directory_commit_contributors_;
ScopedVector<DirectoryUpdateHandler> directory_update_handlers_;
ScopedVector<DirectoryTypeDebugInfoEmitter>
directory_type_debug_info_emitters_;
ScopedVector<ModelTypeSyncWorkerImpl> model_type_sync_workers_;
// Maps of UpdateHandlers and CommitContributors.
// They do not own any of the objects they point to.
UpdateHandlerMap update_handler_map_;
CommitContributorMap commit_contributor_map_;
// Map of DebugInfoEmitters for directory types.
// Non-blocking types handle debug info differently.
// Does not own its contents.
DirectoryTypeDebugInfoEmitterMap directory_type_debug_info_emitter_map_;
// The known ModelSafeWorkers.
std::map<ModelSafeGroup, scoped_refptr<ModelSafeWorker> > workers_map_;
// The directory. Not owned.
syncable::Directory* directory_;
// A copy of the directory's most recent cryptographer.
scoped_ptr<Cryptographer> cryptographer_;
// The set of encrypted types.
ModelTypeSet encrypted_types_;
// The NudgeHandler. Not owned.
NudgeHandler* nudge_handler_;
// The set of enabled directory types.
ModelTypeSet enabled_directory_types_;
// The set of observers of per-type debug info.
//
// Each of the DirectoryTypeDebugInfoEmitters needs such a list. There's
// a lot of them, and their lifetimes are unpredictable, so it makes the
// book-keeping easier if we just store the list here. That way it's
// guaranteed to live as long as this sync backend.
base::ObserverList<TypeDebugInfoObserver> type_debug_info_observers_;
base::WeakPtrFactory<ModelTypeRegistry> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(ModelTypeRegistry);
};
} // namespace syncer
#endif // SYNC_ENGINE_MODEL_TYPE_REGISTRY_H_
|
