| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/bind.h" | |
| 6 #include "base/location.h" | |
| 7 #include "base/single_thread_task_runner.h" | |
| 8 #include "base/thread_task_runner_handle.h" | |
| 9 #include "components/gcm_driver/gcm_driver.h" | |
| 10 #include "components/invalidation/gcm_invalidation_bridge.h" | |
| 11 #include "components/signin/core/browser/profile_oauth2_token_service.h" | |
| 12 #include "components/signin/core/browser/signin_manager.h" | |
| 13 #include "google_apis/gaia/gaia_constants.h" | |
| 14 #include "google_apis/gaia/identity_provider.h" | |
| 15 | |
| 16 namespace invalidation { | |
| 17 namespace { | |
| 18 // For 3rd party developers SenderId should come from application dashboard when | |
| 19 // server side application is registered with Google. Android invalidations use | |
| 20 // legacy format where gmail account can be specificed. Below value is copied | |
| 21 // from Android. | |
| 22 const char kInvalidationsSenderId[] = "ipc.invalidation@gmail.com"; | |
| 23 // In Android world AppId is provided by operating system and should | |
| 24 // match package name and hash of application. In desktop world these values | |
| 25 // are arbitrary and not verified/enforced by registration service (yet). | |
| 26 const char kInvalidationsAppId[] = "com.google.chrome.invalidations"; | |
| 27 | |
| 28 // Cacheinvalidation specific gcm message keys. | |
| 29 const char kContentKey[] = "content"; | |
| 30 const char kEchoTokenKey[] = "echo-token"; | |
| 31 } // namespace | |
| 32 | |
| 33 // Core should be very simple class that implements GCMNetwrokChannelDelegate | |
| 34 // and passes all calls to GCMInvalidationBridge. All calls should be serialized | |
| 35 // through GCMInvalidationBridge to avoid race conditions. | |
| 36 class GCMInvalidationBridge::Core : public syncer::GCMNetworkChannelDelegate, | |
| 37 public base::NonThreadSafe { | |
| 38 public: | |
| 39 Core(base::WeakPtr<GCMInvalidationBridge> bridge, | |
| 40 scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner); | |
| 41 ~Core() override; | |
| 42 | |
| 43 // syncer::GCMNetworkChannelDelegate implementation. | |
| 44 void Initialize(ConnectionStateCallback callback) override; | |
| 45 void RequestToken(RequestTokenCallback callback) override; | |
| 46 void InvalidateToken(const std::string& token) override; | |
| 47 void Register(RegisterCallback callback) override; | |
| 48 void SetMessageReceiver(MessageCallback callback) override; | |
| 49 | |
| 50 void RequestTokenFinished(RequestTokenCallback callback, | |
| 51 const GoogleServiceAuthError& error, | |
| 52 const std::string& token); | |
| 53 | |
| 54 void RegisterFinished(RegisterCallback callback, | |
| 55 const std::string& registration_id, | |
| 56 gcm::GCMClient::Result result); | |
| 57 | |
| 58 void OnIncomingMessage(const std::string& message, | |
| 59 const std::string& echo_token); | |
| 60 | |
| 61 void OnConnectionStateChanged(bool online); | |
| 62 | |
| 63 private: | |
| 64 base::WeakPtr<GCMInvalidationBridge> bridge_; | |
| 65 scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_; | |
| 66 | |
| 67 MessageCallback message_callback_; | |
| 68 ConnectionStateCallback connection_state_callback_; | |
| 69 | |
| 70 base::WeakPtrFactory<Core> weak_factory_; | |
| 71 | |
| 72 DISALLOW_COPY_AND_ASSIGN(Core); | |
| 73 }; | |
| 74 | |
| 75 GCMInvalidationBridge::Core::Core( | |
| 76 base::WeakPtr<GCMInvalidationBridge> bridge, | |
| 77 scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner) | |
| 78 : bridge_(bridge), | |
| 79 ui_thread_task_runner_(ui_thread_task_runner), | |
| 80 weak_factory_(this) { | |
| 81 // Core is created on UI thread but all calls happen on IO thread. | |
| 82 DetachFromThread(); | |
| 83 } | |
| 84 | |
| 85 GCMInvalidationBridge::Core::~Core() {} | |
| 86 | |
| 87 void GCMInvalidationBridge::Core::Initialize(ConnectionStateCallback callback) { | |
| 88 DCHECK(CalledOnValidThread()); | |
| 89 connection_state_callback_ = callback; | |
| 90 // Pass core WeapPtr and TaskRunner to GCMInvalidationBridge for it to be able | |
| 91 // to post back. | |
| 92 ui_thread_task_runner_->PostTask( | |
| 93 FROM_HERE, | |
| 94 base::Bind(&GCMInvalidationBridge::CoreInitializationDone, | |
| 95 bridge_, | |
| 96 weak_factory_.GetWeakPtr(), | |
| 97 base::ThreadTaskRunnerHandle::Get())); | |
| 98 } | |
| 99 | |
| 100 void GCMInvalidationBridge::Core::RequestToken(RequestTokenCallback callback) { | |
| 101 DCHECK(CalledOnValidThread()); | |
| 102 ui_thread_task_runner_->PostTask( | |
| 103 FROM_HERE, | |
| 104 base::Bind(&GCMInvalidationBridge::RequestToken, bridge_, callback)); | |
| 105 } | |
| 106 | |
| 107 void GCMInvalidationBridge::Core::InvalidateToken(const std::string& token) { | |
| 108 DCHECK(CalledOnValidThread()); | |
| 109 ui_thread_task_runner_->PostTask( | |
| 110 FROM_HERE, | |
| 111 base::Bind(&GCMInvalidationBridge::InvalidateToken, bridge_, token)); | |
| 112 } | |
| 113 | |
| 114 void GCMInvalidationBridge::Core::Register(RegisterCallback callback) { | |
| 115 DCHECK(CalledOnValidThread()); | |
| 116 ui_thread_task_runner_->PostTask( | |
| 117 FROM_HERE, | |
| 118 base::Bind(&GCMInvalidationBridge::Register, bridge_, callback)); | |
| 119 } | |
| 120 | |
| 121 void GCMInvalidationBridge::Core::SetMessageReceiver(MessageCallback callback) { | |
| 122 message_callback_ = callback; | |
| 123 ui_thread_task_runner_->PostTask( | |
| 124 FROM_HERE, | |
| 125 base::Bind(&GCMInvalidationBridge::SubscribeForIncomingMessages, | |
| 126 bridge_)); | |
| 127 } | |
| 128 | |
| 129 void GCMInvalidationBridge::Core::RequestTokenFinished( | |
| 130 RequestTokenCallback callback, | |
| 131 const GoogleServiceAuthError& error, | |
| 132 const std::string& token) { | |
| 133 DCHECK(CalledOnValidThread()); | |
| 134 callback.Run(error, token); | |
| 135 } | |
| 136 | |
| 137 void GCMInvalidationBridge::Core::RegisterFinished( | |
| 138 RegisterCallback callback, | |
| 139 const std::string& registration_id, | |
| 140 gcm::GCMClient::Result result) { | |
| 141 DCHECK(CalledOnValidThread()); | |
| 142 callback.Run(registration_id, result); | |
| 143 } | |
| 144 | |
| 145 void GCMInvalidationBridge::Core::OnIncomingMessage( | |
| 146 const std::string& message, | |
| 147 const std::string& echo_token) { | |
| 148 DCHECK(!message_callback_.is_null()); | |
| 149 message_callback_.Run(message, echo_token); | |
| 150 } | |
| 151 | |
| 152 void GCMInvalidationBridge::Core::OnConnectionStateChanged(bool online) { | |
| 153 if (!connection_state_callback_.is_null()) { | |
| 154 connection_state_callback_.Run(online); | |
| 155 } | |
| 156 } | |
| 157 | |
| 158 GCMInvalidationBridge::GCMInvalidationBridge( | |
| 159 gcm::GCMDriver* gcm_driver, | |
| 160 IdentityProvider* identity_provider) | |
| 161 : OAuth2TokenService::Consumer("gcm_network_channel"), | |
| 162 gcm_driver_(gcm_driver), | |
| 163 identity_provider_(identity_provider), | |
| 164 subscribed_for_incoming_messages_(false), | |
| 165 weak_factory_(this) {} | |
| 166 | |
| 167 GCMInvalidationBridge::~GCMInvalidationBridge() { | |
| 168 if (subscribed_for_incoming_messages_) { | |
| 169 gcm_driver_->RemoveAppHandler(kInvalidationsAppId); | |
| 170 gcm_driver_->RemoveConnectionObserver(this); | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 scoped_ptr<syncer::GCMNetworkChannelDelegate> | |
| 175 GCMInvalidationBridge::CreateDelegate() { | |
| 176 DCHECK(CalledOnValidThread()); | |
| 177 scoped_ptr<syncer::GCMNetworkChannelDelegate> core(new Core( | |
| 178 weak_factory_.GetWeakPtr(), base::ThreadTaskRunnerHandle::Get())); | |
| 179 return core.Pass(); | |
| 180 } | |
| 181 | |
| 182 void GCMInvalidationBridge::CoreInitializationDone( | |
| 183 base::WeakPtr<Core> core, | |
| 184 scoped_refptr<base::SingleThreadTaskRunner> core_thread_task_runner) { | |
| 185 DCHECK(CalledOnValidThread()); | |
| 186 core_ = core; | |
| 187 core_thread_task_runner_ = core_thread_task_runner; | |
| 188 } | |
| 189 | |
| 190 void GCMInvalidationBridge::RequestToken( | |
| 191 syncer::GCMNetworkChannelDelegate::RequestTokenCallback callback) { | |
| 192 DCHECK(CalledOnValidThread()); | |
| 193 if (access_token_request_ != NULL) { | |
| 194 // Report previous request as cancelled. | |
| 195 GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED); | |
| 196 std::string access_token; | |
| 197 core_thread_task_runner_->PostTask( | |
| 198 FROM_HERE, | |
| 199 base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished, | |
| 200 core_, | |
| 201 request_token_callback_, | |
| 202 error, | |
| 203 access_token)); | |
| 204 } | |
| 205 request_token_callback_ = callback; | |
| 206 OAuth2TokenService::ScopeSet scopes; | |
| 207 scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope); | |
| 208 access_token_request_ = identity_provider_->GetTokenService()->StartRequest( | |
| 209 identity_provider_->GetActiveAccountId(), scopes, this); | |
| 210 } | |
| 211 | |
| 212 void GCMInvalidationBridge::OnGetTokenSuccess( | |
| 213 const OAuth2TokenService::Request* request, | |
| 214 const std::string& access_token, | |
| 215 const base::Time& expiration_time) { | |
| 216 DCHECK(CalledOnValidThread()); | |
| 217 DCHECK_EQ(access_token_request_, request); | |
| 218 core_thread_task_runner_->PostTask( | |
| 219 FROM_HERE, | |
| 220 base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished, | |
| 221 core_, | |
| 222 request_token_callback_, | |
| 223 GoogleServiceAuthError::AuthErrorNone(), | |
| 224 access_token)); | |
| 225 request_token_callback_.Reset(); | |
| 226 access_token_request_.reset(); | |
| 227 } | |
| 228 | |
| 229 void GCMInvalidationBridge::OnGetTokenFailure( | |
| 230 const OAuth2TokenService::Request* request, | |
| 231 const GoogleServiceAuthError& error) { | |
| 232 DCHECK(CalledOnValidThread()); | |
| 233 DCHECK_EQ(access_token_request_, request); | |
| 234 core_thread_task_runner_->PostTask( | |
| 235 FROM_HERE, | |
| 236 base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished, | |
| 237 core_, | |
| 238 request_token_callback_, | |
| 239 error, | |
| 240 std::string())); | |
| 241 request_token_callback_.Reset(); | |
| 242 access_token_request_.reset(); | |
| 243 } | |
| 244 | |
| 245 void GCMInvalidationBridge::InvalidateToken(const std::string& token) { | |
| 246 DCHECK(CalledOnValidThread()); | |
| 247 OAuth2TokenService::ScopeSet scopes; | |
| 248 scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope); | |
| 249 identity_provider_->GetTokenService()->InvalidateToken( | |
| 250 identity_provider_->GetActiveAccountId(), scopes, token); | |
| 251 } | |
| 252 | |
| 253 void GCMInvalidationBridge::Register( | |
| 254 syncer::GCMNetworkChannelDelegate::RegisterCallback callback) { | |
| 255 DCHECK(CalledOnValidThread()); | |
| 256 // No-op if GCMClient is disabled. | |
| 257 if (gcm_driver_ == NULL) | |
| 258 return; | |
| 259 | |
| 260 std::vector<std::string> sender_ids; | |
| 261 sender_ids.push_back(kInvalidationsSenderId); | |
| 262 gcm_driver_->Register(kInvalidationsAppId, | |
| 263 sender_ids, | |
| 264 base::Bind(&GCMInvalidationBridge::RegisterFinished, | |
| 265 weak_factory_.GetWeakPtr(), | |
| 266 callback)); | |
| 267 } | |
| 268 | |
| 269 void GCMInvalidationBridge::RegisterFinished( | |
| 270 syncer::GCMNetworkChannelDelegate::RegisterCallback callback, | |
| 271 const std::string& registration_id, | |
| 272 gcm::GCMClient::Result result) { | |
| 273 DCHECK(CalledOnValidThread()); | |
| 274 core_thread_task_runner_->PostTask( | |
| 275 FROM_HERE, | |
| 276 base::Bind(&GCMInvalidationBridge::Core::RegisterFinished, | |
| 277 core_, | |
| 278 callback, | |
| 279 registration_id, | |
| 280 result)); | |
| 281 } | |
| 282 | |
| 283 void GCMInvalidationBridge::Unregister() { | |
| 284 DCHECK(CalledOnValidThread()); | |
| 285 // No-op if GCMClient is disabled. | |
| 286 if (gcm_driver_ == NULL) | |
| 287 return; | |
| 288 | |
| 289 gcm_driver_->Unregister( | |
| 290 kInvalidationsAppId, | |
| 291 base::Bind(&GCMInvalidationBridge::UnregisterFinishedNoOp)); | |
| 292 } | |
| 293 | |
| 294 // static | |
| 295 void GCMInvalidationBridge::UnregisterFinishedNoOp( | |
| 296 gcm::GCMClient::Result result) { | |
| 297 // No-op. | |
| 298 } | |
| 299 | |
| 300 void GCMInvalidationBridge::SubscribeForIncomingMessages() { | |
| 301 // No-op if GCMClient is disabled. | |
| 302 if (gcm_driver_ == NULL) | |
| 303 return; | |
| 304 | |
| 305 DCHECK(!subscribed_for_incoming_messages_); | |
| 306 gcm_driver_->AddAppHandler(kInvalidationsAppId, this); | |
| 307 gcm_driver_->AddConnectionObserver(this); | |
| 308 core_thread_task_runner_->PostTask( | |
| 309 FROM_HERE, | |
| 310 base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged, | |
| 311 core_, | |
| 312 gcm_driver_->IsConnected())); | |
| 313 | |
| 314 subscribed_for_incoming_messages_ = true; | |
| 315 } | |
| 316 | |
| 317 void GCMInvalidationBridge::ShutdownHandler() { | |
| 318 // Nothing to do. | |
| 319 } | |
| 320 | |
| 321 void GCMInvalidationBridge::OnMessage( | |
| 322 const std::string& app_id, | |
| 323 const gcm::GCMClient::IncomingMessage& message) { | |
| 324 gcm::GCMClient::MessageData::const_iterator it; | |
| 325 std::string content; | |
| 326 std::string echo_token; | |
| 327 it = message.data.find(kContentKey); | |
| 328 if (it != message.data.end()) | |
| 329 content = it->second; | |
| 330 it = message.data.find(kEchoTokenKey); | |
| 331 if (it != message.data.end()) | |
| 332 echo_token = it->second; | |
| 333 | |
| 334 core_thread_task_runner_->PostTask( | |
| 335 FROM_HERE, | |
| 336 base::Bind(&GCMInvalidationBridge::Core::OnIncomingMessage, | |
| 337 core_, | |
| 338 content, | |
| 339 echo_token)); | |
| 340 } | |
| 341 | |
| 342 void GCMInvalidationBridge::OnMessagesDeleted(const std::string& app_id) { | |
| 343 // Cacheinvalidation doesn't use long lived non-collapsable messages with GCM. | |
| 344 // Android implementation of cacheinvalidation doesn't handle MessagesDeleted | |
| 345 // callback so this should be no-op in desktop version as well. | |
| 346 } | |
| 347 | |
| 348 void GCMInvalidationBridge::OnSendError( | |
| 349 const std::string& app_id, | |
| 350 const gcm::GCMClient::SendErrorDetails& send_error_details) { | |
| 351 // cacheinvalidation doesn't send messages over GCM. | |
| 352 NOTREACHED(); | |
| 353 } | |
| 354 | |
| 355 void GCMInvalidationBridge::OnSendAcknowledged( | |
| 356 const std::string& app_id, | |
| 357 const std::string& message_id) { | |
| 358 // cacheinvalidation doesn't send messages over GCM. | |
| 359 NOTREACHED(); | |
| 360 } | |
| 361 | |
| 362 void GCMInvalidationBridge::OnConnected(const net::IPEndPoint& ip_endpoint) { | |
| 363 core_thread_task_runner_->PostTask( | |
| 364 FROM_HERE, | |
| 365 base::Bind( | |
| 366 &GCMInvalidationBridge::Core::OnConnectionStateChanged, core_, true)); | |
| 367 } | |
| 368 | |
| 369 void GCMInvalidationBridge::OnDisconnected() { | |
| 370 core_thread_task_runner_->PostTask( | |
| 371 FROM_HERE, | |
| 372 base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged, | |
| 373 core_, | |
| 374 false)); | |
| 375 } | |
| 376 | |
| 377 } // namespace invalidation | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1191393008:
Introduce a layering in the invalidation component as public and impl (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master