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 COMPONENTS_INVALIDATION_IMPL_TICL_INVALIDATION_SERVICE_H_
#define COMPONENTS_INVALIDATION_IMPL_TICL_INVALIDATION_SERVICE_H_
#include <memory>
#include <string>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/threading/non_thread_safe.h"
#include "base/timer/timer.h"
#include "base/values.h"
#include "components/invalidation/impl/invalidation_logger.h"
#include "components/invalidation/impl/invalidator_registrar.h"
#include "components/invalidation/impl/ticl_settings_provider.h"
#include "components/invalidation/public/invalidation_handler.h"
#include "components/invalidation/public/invalidation_service.h"
#include "components/keyed_service/core/keyed_service.h"
#include "google_apis/gaia/identity_provider.h"
#include "google_apis/gaia/oauth2_token_service.h"
#include "net/base/backoff_entry.h"
namespace gcm {
class GCMDriver;
}
namespace net {
class URLRequestContextGetter;
}
namespace syncer {
class InvalidationStateTracker;
class Invalidator;
}
namespace invalidation {
class GCMInvalidationBridge;
// This InvalidationService wraps the C++ Invalidation Client (TICL) library.
// It provides invalidations for desktop platforms (Win, Mac, Linux).
class TiclInvalidationService : public base::NonThreadSafe,
public InvalidationService,
public OAuth2TokenService::Consumer,
public OAuth2TokenService::Observer,
public IdentityProvider::Observer,
public TiclSettingsProvider::Observer,
public syncer::InvalidationHandler {
public:
enum InvalidationNetworkChannel {
PUSH_CLIENT_CHANNEL = 0,
GCM_NETWORK_CHANNEL = 1,
// This enum is used in UMA_HISTOGRAM_ENUMERATION. Insert new values above
// this line.
NETWORK_CHANNELS_COUNT = 2
};
TiclInvalidationService(
const std::string& user_agent,
std::unique_ptr<IdentityProvider> identity_provider,
std::unique_ptr<TiclSettingsProvider> settings_provider,
gcm::GCMDriver* gcm_driver,
const scoped_refptr<net::URLRequestContextGetter>& request_context);
~TiclInvalidationService() override;
void Init(std::unique_ptr<syncer::InvalidationStateTracker>
invalidation_state_tracker);
// InvalidationService implementation.
// It is an error to have registered handlers when the service is destroyed.
void RegisterInvalidationHandler(
syncer::InvalidationHandler* handler) override;
bool UpdateRegisteredInvalidationIds(syncer::InvalidationHandler* handler,
const syncer::ObjectIdSet& ids) override;
void UnregisterInvalidationHandler(
syncer::InvalidationHandler* handler) override;
syncer::InvalidatorState GetInvalidatorState() const override;
std::string GetInvalidatorClientId() const override;
InvalidationLogger* GetInvalidationLogger() override;
void RequestDetailedStatus(
base::Callback<void(const base::DictionaryValue&)> caller) const override;
IdentityProvider* GetIdentityProvider() override;
void RequestAccessToken();
// OAuth2TokenService::Consumer implementation
void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
const std::string& access_token,
const base::Time& expiration_time) override;
void OnGetTokenFailure(const OAuth2TokenService::Request* request,
const GoogleServiceAuthError& error) override;
// OAuth2TokenService::Observer implementation
void OnRefreshTokenAvailable(const std::string& account_id) override;
void OnRefreshTokenRevoked(const std::string& account_id) override;
// IdentityProvider::Observer implementation.
void OnActiveAccountLogout() override;
// TiclSettingsProvider::Observer implementation.
void OnUseGCMChannelChanged() override;
// syncer::InvalidationHandler implementation.
void OnInvalidatorStateChange(syncer::InvalidatorState state) override;
void OnIncomingInvalidation(
const syncer::ObjectIdInvalidationMap& invalidation_map) override;
std::string GetOwnerName() const override;
protected:
// Initializes with an injected invalidator.
void InitForTest(std::unique_ptr<syncer::InvalidationStateTracker>
invalidation_state_tracker,
syncer::Invalidator* invalidator);
private:
friend class TiclInvalidationServiceTestDelegate;
friend class TiclProfileSettingsProviderTest;
bool IsReadyToStart();
bool IsStarted() const;
void StartInvalidator(InvalidationNetworkChannel network_channel);
void UpdateInvalidationNetworkChannel();
void UpdateInvalidatorCredentials();
void StopInvalidator();
const std::string user_agent_;
std::unique_ptr<IdentityProvider> identity_provider_;
std::unique_ptr<TiclSettingsProvider> settings_provider_;
std::unique_ptr<syncer::InvalidatorRegistrar> invalidator_registrar_;
std::unique_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker_;
std::unique_ptr<syncer::Invalidator> invalidator_;
// TiclInvalidationService needs to remember access token in order to
// invalidate it with OAuth2TokenService.
std::string access_token_;
// TiclInvalidationService needs to hold reference to access_token_request_
// for the duration of request in order to receive callbacks.
std::unique_ptr<OAuth2TokenService::Request> access_token_request_;
base::OneShotTimer request_access_token_retry_timer_;
net::BackoffEntry request_access_token_backoff_;
InvalidationNetworkChannel network_channel_type_;
gcm::GCMDriver* gcm_driver_;
std::unique_ptr<GCMInvalidationBridge> gcm_invalidation_bridge_;
scoped_refptr<net::URLRequestContextGetter> request_context_;
// The invalidation logger object we use to record state changes
// and invalidations.
InvalidationLogger logger_;
// Keep a copy of the important parameters used in network channel creation
// for debugging.
base::DictionaryValue network_channel_options_;
DISALLOW_COPY_AND_ASSIGN(TiclInvalidationService);
};
} // namespace invalidation
#endif // COMPONENTS_INVALIDATION_IMPL_TICL_INVALIDATION_SERVICE_H_
|
