Home | History | Annotate | Download | only in invalidation 
      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 (at) 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   virtual ~Core();
     42 
     43   // syncer::GCMNetworkChannelDelegate implementation.
     44   virtual void Initialize(ConnectionStateCallback callback) OVERRIDE;
     45   virtual void RequestToken(RequestTokenCallback callback) OVERRIDE;
     46   virtual void InvalidateToken(const std::string& token) OVERRIDE;
     47   virtual void Register(RegisterCallback callback) OVERRIDE;
     48   virtual 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 }
    171 
    172 scoped_ptr<syncer::GCMNetworkChannelDelegate>
    173 GCMInvalidationBridge::CreateDelegate() {
    174   DCHECK(CalledOnValidThread());
    175   scoped_ptr<syncer::GCMNetworkChannelDelegate> core(new Core(
    176       weak_factory_.GetWeakPtr(), base::ThreadTaskRunnerHandle::Get()));
    177   return core.Pass();
    178 }
    179 
    180 void GCMInvalidationBridge::CoreInitializationDone(
    181     base::WeakPtr<Core> core,
    182     scoped_refptr<base::SingleThreadTaskRunner> core_thread_task_runner) {
    183   DCHECK(CalledOnValidThread());
    184   core_ = core;
    185   core_thread_task_runner_ = core_thread_task_runner;
    186 }
    187 
    188 void GCMInvalidationBridge::RequestToken(
    189     syncer::GCMNetworkChannelDelegate::RequestTokenCallback callback) {
    190   DCHECK(CalledOnValidThread());
    191   if (access_token_request_ != NULL) {
    192     // Report previous request as cancelled.
    193     GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
    194     std::string access_token;
    195     core_thread_task_runner_->PostTask(
    196         FROM_HERE,
    197         base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
    198                    core_,
    199                    request_token_callback_,
    200                    error,
    201                    access_token));
    202   }
    203   request_token_callback_ = callback;
    204   OAuth2TokenService::ScopeSet scopes;
    205   scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
    206   access_token_request_ = identity_provider_->GetTokenService()->StartRequest(
    207       identity_provider_->GetActiveAccountId(), scopes, this);
    208 }
    209 
    210 void GCMInvalidationBridge::OnGetTokenSuccess(
    211     const OAuth2TokenService::Request* request,
    212     const std::string& access_token,
    213     const base::Time& expiration_time) {
    214   DCHECK(CalledOnValidThread());
    215   DCHECK_EQ(access_token_request_, request);
    216   core_thread_task_runner_->PostTask(
    217       FROM_HERE,
    218       base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
    219                  core_,
    220                  request_token_callback_,
    221                  GoogleServiceAuthError::AuthErrorNone(),
    222                  access_token));
    223   request_token_callback_.Reset();
    224   access_token_request_.reset();
    225 }
    226 
    227 void GCMInvalidationBridge::OnGetTokenFailure(
    228     const OAuth2TokenService::Request* request,
    229     const GoogleServiceAuthError& error) {
    230   DCHECK(CalledOnValidThread());
    231   DCHECK_EQ(access_token_request_, request);
    232   core_thread_task_runner_->PostTask(
    233       FROM_HERE,
    234       base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
    235                  core_,
    236                  request_token_callback_,
    237                  error,
    238                  std::string()));
    239   request_token_callback_.Reset();
    240   access_token_request_.reset();
    241 }
    242 
    243 void GCMInvalidationBridge::InvalidateToken(const std::string& token) {
    244   DCHECK(CalledOnValidThread());
    245   OAuth2TokenService::ScopeSet scopes;
    246   scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
    247   identity_provider_->GetTokenService()->InvalidateToken(
    248       identity_provider_->GetActiveAccountId(), scopes, token);
    249 }
    250 
    251 void GCMInvalidationBridge::Register(
    252     syncer::GCMNetworkChannelDelegate::RegisterCallback callback) {
    253   DCHECK(CalledOnValidThread());
    254   // No-op if GCMClient is disabled.
    255   if (gcm_driver_ == NULL)
    256     return;
    257 
    258   std::vector<std::string> sender_ids;
    259   sender_ids.push_back(kInvalidationsSenderId);
    260   gcm_driver_->Register(kInvalidationsAppId,
    261                          sender_ids,
    262                          base::Bind(&GCMInvalidationBridge::RegisterFinished,
    263                                     weak_factory_.GetWeakPtr(),
    264                                     callback));
    265 }
    266 
    267 void GCMInvalidationBridge::RegisterFinished(
    268     syncer::GCMNetworkChannelDelegate::RegisterCallback callback,
    269     const std::string& registration_id,
    270     gcm::GCMClient::Result result) {
    271   DCHECK(CalledOnValidThread());
    272   core_thread_task_runner_->PostTask(
    273       FROM_HERE,
    274       base::Bind(&GCMInvalidationBridge::Core::RegisterFinished,
    275                  core_,
    276                  callback,
    277                  registration_id,
    278                  result));
    279 }
    280 
    281 void GCMInvalidationBridge::SubscribeForIncomingMessages() {
    282   // No-op if GCMClient is disabled.
    283   if (gcm_driver_ == NULL)
    284     return;
    285 
    286   DCHECK(!subscribed_for_incoming_messages_);
    287   gcm_driver_->AddAppHandler(kInvalidationsAppId, this);
    288   core_thread_task_runner_->PostTask(
    289       FROM_HERE,
    290       base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
    291                  core_,
    292                  gcm_driver_->IsConnected()));
    293 
    294   subscribed_for_incoming_messages_ = true;
    295 }
    296 
    297 void GCMInvalidationBridge::ShutdownHandler() {
    298   // Nothing to do.
    299 }
    300 
    301 void GCMInvalidationBridge::OnMessage(
    302     const std::string& app_id,
    303     const gcm::GCMClient::IncomingMessage& message) {
    304   gcm::GCMClient::MessageData::const_iterator it;
    305   std::string content;
    306   std::string echo_token;
    307   it = message.data.find(kContentKey);
    308   if (it != message.data.end())
    309     content = it->second;
    310   it = message.data.find(kEchoTokenKey);
    311   if (it != message.data.end())
    312     echo_token = it->second;
    313 
    314   core_thread_task_runner_->PostTask(
    315       FROM_HERE,
    316       base::Bind(&GCMInvalidationBridge::Core::OnIncomingMessage,
    317                  core_,
    318                  content,
    319                  echo_token));
    320 }
    321 
    322 void GCMInvalidationBridge::OnMessagesDeleted(const std::string& app_id) {
    323   // Cacheinvalidation doesn't use long lived non-collapsable messages with GCM.
    324   // Android implementation of cacheinvalidation doesn't handle MessagesDeleted
    325   // callback so this should be no-op in desktop version as well.
    326 }
    327 
    328 void GCMInvalidationBridge::OnSendError(
    329     const std::string& app_id,
    330     const gcm::GCMClient::SendErrorDetails& send_error_details) {
    331   // cacheinvalidation doesn't send messages over GCM.
    332   NOTREACHED();
    333 }
    334 
    335 void GCMInvalidationBridge::OnConnected(const net::IPEndPoint& ip_endpoint) {
    336   core_thread_task_runner_->PostTask(
    337       FROM_HERE,
    338       base::Bind(
    339           &GCMInvalidationBridge::Core::OnConnectionStateChanged, core_, true));
    340 }
    341 
    342 void GCMInvalidationBridge::OnDisconnected() {
    343   core_thread_task_runner_->PostTask(
    344       FROM_HERE,
    345       base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
    346                  core_,
    347                  false));
    348 }
    349 
    350 
    351 }  // namespace invalidation
    352