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
|
// Copyright 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.
//
// A simple wrapper around invalidation::InvalidationClient that
// handles all the startup/shutdown details and hookups.
#ifndef SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_
#define SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_
#include <string>
#include "base/basictypes.h"
#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/threading/non_thread_safe.h"
#include "google/cacheinvalidation/include/invalidation-listener.h"
#include "sync/base/sync_export.h"
#include "sync/internal_api/public/util/weak_handle.h"
#include "sync/notifier/ack_handler.h"
#include "sync/notifier/invalidation_state_tracker.h"
#include "sync/notifier/invalidator_state.h"
#include "sync/notifier/push_client_channel.h"
#include "sync/notifier/state_writer.h"
#include "sync/notifier/sync_system_resources.h"
#include "sync/notifier/unacked_invalidation_set.h"
namespace buzz {
class XmppTaskParentInterface;
} // namespace buzz
namespace notifier {
class PushClient;
} // namespace notifier
namespace syncer {
class ObjectIdInvalidationMap;
class RegistrationManager;
// SyncInvalidationListener is not thread-safe and lives on the sync
// thread.
class SYNC_EXPORT_PRIVATE SyncInvalidationListener
: public NON_EXPORTED_BASE(invalidation::InvalidationListener),
public StateWriter,
public SyncNetworkChannel::Observer,
public AckHandler,
public base::NonThreadSafe {
public:
typedef base::Callback<invalidation::InvalidationClient*(
invalidation::SystemResources*,
int,
const invalidation::string&,
const invalidation::string&,
invalidation::InvalidationListener*)> CreateInvalidationClientCallback;
class SYNC_EXPORT_PRIVATE Delegate {
public:
virtual ~Delegate();
virtual void OnInvalidate(
const ObjectIdInvalidationMap& invalidations) = 0;
virtual void OnInvalidatorStateChange(InvalidatorState state) = 0;
};
explicit SyncInvalidationListener(
scoped_ptr<notifier::PushClient> push_client);
// Calls Stop().
virtual ~SyncInvalidationListener();
// Does not take ownership of |delegate| or |state_writer|.
// |invalidation_state_tracker| must be initialized.
void Start(
const CreateInvalidationClientCallback&
create_invalidation_client_callback,
const std::string& client_id, const std::string& client_info,
const std::string& invalidation_bootstrap_data,
const UnackedInvalidationsMap& initial_object_states,
const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
Delegate* delegate);
void UpdateCredentials(const std::string& email, const std::string& token);
// Update the set of object IDs that we're interested in getting
// notifications for. May be called at any time.
void UpdateRegisteredIds(const ObjectIdSet& ids);
// invalidation::InvalidationListener implementation.
virtual void Ready(
invalidation::InvalidationClient* client) OVERRIDE;
virtual void Invalidate(
invalidation::InvalidationClient* client,
const invalidation::Invalidation& invalidation,
const invalidation::AckHandle& ack_handle) OVERRIDE;
virtual void InvalidateUnknownVersion(
invalidation::InvalidationClient* client,
const invalidation::ObjectId& object_id,
const invalidation::AckHandle& ack_handle) OVERRIDE;
virtual void InvalidateAll(
invalidation::InvalidationClient* client,
const invalidation::AckHandle& ack_handle) OVERRIDE;
virtual void InformRegistrationStatus(
invalidation::InvalidationClient* client,
const invalidation::ObjectId& object_id,
invalidation::InvalidationListener::RegistrationState reg_state) OVERRIDE;
virtual void InformRegistrationFailure(
invalidation::InvalidationClient* client,
const invalidation::ObjectId& object_id,
bool is_transient,
const std::string& error_message) OVERRIDE;
virtual void ReissueRegistrations(
invalidation::InvalidationClient* client,
const std::string& prefix,
int prefix_length) OVERRIDE;
virtual void InformError(
invalidation::InvalidationClient* client,
const invalidation::ErrorInfo& error_info) OVERRIDE;
// AckHandler implementation.
virtual void Acknowledge(
const invalidation::ObjectId& id,
const syncer::AckHandle& handle) OVERRIDE;
virtual void Drop(
const invalidation::ObjectId& id,
const syncer::AckHandle& handle) OVERRIDE;
// StateWriter implementation.
virtual void WriteState(const std::string& state) OVERRIDE;
// SyncNetworkChannel::Observer implementation.
virtual void OnNetworkChannelStateChanged(
InvalidatorState invalidator_state) OVERRIDE;
void DoRegistrationUpdate();
void StopForTest();
private:
void Stop();
InvalidatorState GetState() const;
void EmitStateChange();
// Sends invalidations to their appropriate destination.
//
// If there are no observers registered for them, they will be saved for
// later.
//
// If there are observers registered, they will be saved (to make sure we
// don't drop them until they've been acted on) and emitted to the observers.
void DispatchInvalidations(const ObjectIdInvalidationMap& invalidations);
// Saves invalidations.
//
// This call isn't synchronous so we can't guarantee these invalidations will
// be safely on disk by the end of the call, but it should ensure that the
// data makes it to disk eventually.
void SaveInvalidations(const ObjectIdInvalidationMap& to_save);
// Emits previously saved invalidations to their registered observers.
void EmitSavedInvalidations(const ObjectIdInvalidationMap& to_emit);
WeakHandle<AckHandler> GetThisAsAckHandler();
PushClientChannel push_client_channel_;
SyncSystemResources sync_system_resources_;
UnackedInvalidationsMap unacked_invalidations_map_;
WeakHandle<InvalidationStateTracker> invalidation_state_tracker_;
Delegate* delegate_;
scoped_ptr<invalidation::InvalidationClient> invalidation_client_;
scoped_ptr<RegistrationManager> registration_manager_;
// Stored to pass to |registration_manager_| on start.
ObjectIdSet registered_ids_;
// The states of the ticl and the push client.
InvalidatorState ticl_state_;
InvalidatorState push_client_state_;
base::WeakPtrFactory<SyncInvalidationListener> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(SyncInvalidationListener);
};
} // namespace syncer
#endif // SYNC_NOTIFIER_SYNC_INVALIDATION_LISTENER_H_
|
