components/gcm_driver/gcm_driver_desktop.cc

   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 "components/gcm_driver/gcm_driver_desktop.h"
   6
   7 #include <utility>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/files/file_path.h"
  12 #include "base/location.h"
  13 #include "base/logging.h"
  14 #include "base/sequenced_task_runner.h"
  15 #include "base/threading/sequenced_worker_pool.h"
  16 #include "components/gcm_driver/gcm_app_handler.h"
  17 #include "components/gcm_driver/gcm_channel_status_syncer.h"
  18 #include "components/gcm_driver/gcm_client_factory.h"
  19 #include "components/gcm_driver/gcm_delayed_task_controller.h"
  20 #include "components/gcm_driver/system_encryptor.h"
  21 #include "google_apis/gcm/engine/account_mapping.h"
  22 #include "net/base/ip_endpoint.h"
  23 #include "net/url_request/url_request_context_getter.h"
  24
  25 namespace gcm {
  26
  27 class GCMDriverDesktop::IOWorker : public GCMClient::Delegate {
  28  public:
  29   // Called on UI thread.
  30   IOWorker(const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
  31            const scoped_refptr<base::SequencedTaskRunner>& io_thread);
  32   virtual ~IOWorker();
  33
  34   // Overridden from GCMClient::Delegate:
  35   // Called on IO thread.
  36   virtual void OnRegisterFinished(const std::string& app_id,
  37                                   const std::string& registration_id,
  38                                   GCMClient::Result result) OVERRIDE;
  39   virtual void OnUnregisterFinished(const std::string& app_id,
  40                                     GCMClient::Result result) OVERRIDE;
  41   virtual void OnSendFinished(const std::string& app_id,
  42                               const std::string& message_id,
  43                               GCMClient::Result result) OVERRIDE;
  44   virtual void OnMessageReceived(
  45       const std::string& app_id,
  46       const GCMClient::IncomingMessage& message) OVERRIDE;
  47   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
  48   virtual void OnMessageSendError(
  49       const std::string& app_id,
  50       const GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
  51   virtual void OnSendAcknowledged(const std::string& app_id,
  52                                   const std::string& message_id) OVERRIDE;
  53   virtual void OnGCMReady() OVERRIDE;
  54   virtual void OnActivityRecorded() OVERRIDE;
  55   virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE;
  56   virtual void OnDisconnected() OVERRIDE;
  57
  58   // Called on IO thread.
  59   void Initialize(
  60       scoped_ptr<GCMClientFactory> gcm_client_factory,
  61       const GCMClient::ChromeBuildInfo& chrome_build_info,
  62       const base::FilePath& store_path,
  63       const scoped_refptr<net::URLRequestContextGetter>& request_context,
  64       const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
  65   void Start(const base::WeakPtr<GCMDriverDesktop>& service);
  66   void Stop();
  67   void CheckOut();
  68   void Register(const std::string& app_id,
  69                 const std::vector<std::string>& sender_ids);
  70   void Unregister(const std::string& app_id);
  71   void Send(const std::string& app_id,
  72             const std::string& receiver_id,
  73             const GCMClient::OutgoingMessage& message);
  74   void GetGCMStatistics(bool clear_logs);
  75   void SetGCMRecording(bool recording);
  76
  77   void SetAccountsForCheckin(
  78       const std::map<std::string, std::string>& account_tokens);
  79   void UpdateAccountMapping(const AccountMapping& account_mapping);
  80   void RemoveAccountMapping(const std::string& account_id);
  81
  82   // For testing purpose. Can be called from UI thread. Use with care.
  83   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
  84
  85  private:
  86   scoped_refptr<base::SequencedTaskRunner> ui_thread_;
  87   scoped_refptr<base::SequencedTaskRunner> io_thread_;
  88
  89   base::WeakPtr<GCMDriverDesktop> service_;
  90
  91   scoped_ptr<GCMClient> gcm_client_;
  92
  93   DISALLOW_COPY_AND_ASSIGN(IOWorker);
  94 };
  95
  96 GCMDriverDesktop::IOWorker::IOWorker(
  97     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
  98     const scoped_refptr<base::SequencedTaskRunner>& io_thread)
  99     : ui_thread_(ui_thread),
 100       io_thread_(io_thread) {
 101   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 102 }
 103
 104 GCMDriverDesktop::IOWorker::~IOWorker() {
 105   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 106 }
 107
 108 void GCMDriverDesktop::IOWorker::Initialize(
 109     scoped_ptr<GCMClientFactory> gcm_client_factory,
 110     const GCMClient::ChromeBuildInfo& chrome_build_info,
 111     const base::FilePath& store_path,
 112     const scoped_refptr<net::URLRequestContextGetter>& request_context,
 113     const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner) {
 114   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 115
 116   gcm_client_ = gcm_client_factory->BuildInstance();
 117
 118   gcm_client_->Initialize(chrome_build_info,
 119                           store_path,
 120                           blocking_task_runner,
 121                           request_context,
 122                           make_scoped_ptr<Encryptor>(new SystemEncryptor),
 123                           this);
 124 }
 125
 126 void GCMDriverDesktop::IOWorker::OnRegisterFinished(
 127     const std::string& app_id,
 128     const std::string& registration_id,
 129     GCMClient::Result result) {
 130   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 131
 132   ui_thread_->PostTask(
 133       FROM_HERE,
 134       base::Bind(&GCMDriverDesktop::RegisterFinished, service_, app_id,
 135                  registration_id, result));
 136 }
 137
 138 void GCMDriverDesktop::IOWorker::OnUnregisterFinished(
 139     const std::string& app_id,
 140     GCMClient::Result result) {
 141   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 142
 143   ui_thread_->PostTask(FROM_HERE,
 144                        base::Bind(&GCMDriverDesktop::UnregisterFinished,
 145                                   service_,
 146                                   app_id,
 147                                   result));
 148 }
 149
 150 void GCMDriverDesktop::IOWorker::OnSendFinished(const std::string& app_id,
 151                                                 const std::string& message_id,
 152                                                 GCMClient::Result result) {
 153   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 154
 155   ui_thread_->PostTask(
 156       FROM_HERE,
 157       base::Bind(&GCMDriverDesktop::SendFinished, service_, app_id, message_id,
 158                  result));
 159 }
 160
 161 void GCMDriverDesktop::IOWorker::OnMessageReceived(
 162     const std::string& app_id,
 163     const GCMClient::IncomingMessage& message) {
 164   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 165
 166   ui_thread_->PostTask(
 167       FROM_HERE,
 168       base::Bind(&GCMDriverDesktop::MessageReceived,
 169                  service_,
 170                  app_id,
 171                  message));
 172 }
 173
 174 void GCMDriverDesktop::IOWorker::OnMessagesDeleted(const std::string& app_id) {
 175   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 176
 177   ui_thread_->PostTask(
 178       FROM_HERE,
 179       base::Bind(&GCMDriverDesktop::MessagesDeleted, service_, app_id));
 180 }
 181
 182 void GCMDriverDesktop::IOWorker::OnMessageSendError(
 183     const std::string& app_id,
 184     const GCMClient::SendErrorDetails& send_error_details) {
 185   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 186
 187   ui_thread_->PostTask(
 188       FROM_HERE,
 189       base::Bind(&GCMDriverDesktop::MessageSendError, service_, app_id,
 190                  send_error_details));
 191 }
 192
 193 void GCMDriverDesktop::IOWorker::OnSendAcknowledged(
 194     const std::string& app_id,
 195     const std::string& message_id) {
 196   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 197
 198   ui_thread_->PostTask(
 199       FROM_HERE,
 200       base::Bind(
 201           &GCMDriverDesktop::SendAcknowledged, service_, app_id, message_id));
 202 }
 203
 204 void GCMDriverDesktop::IOWorker::OnGCMReady() {
 205   ui_thread_->PostTask(
 206       FROM_HERE,
 207       base::Bind(&GCMDriverDesktop::GCMClientReady, service_));
 208 }
 209
 210 void GCMDriverDesktop::IOWorker::OnActivityRecorded() {
 211   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 212   // When an activity is recorded, get all the stats and refresh the UI of
 213   // gcm-internals page.
 214   GetGCMStatistics(false);
 215 }
 216
 217 void GCMDriverDesktop::IOWorker::OnConnected(
 218     const net::IPEndPoint& ip_endpoint) {
 219   ui_thread_->PostTask(FROM_HERE,
 220                        base::Bind(&GCMDriverDesktop::OnConnected,
 221                                   service_,
 222                                   ip_endpoint));
 223 }
 224
 225 void GCMDriverDesktop::IOWorker::OnDisconnected() {
 226   ui_thread_->PostTask(FROM_HERE,
 227                        base::Bind(&GCMDriverDesktop::OnDisconnected, service_));
 228 }
 229
 230 void GCMDriverDesktop::IOWorker::Start(
 231     const base::WeakPtr<GCMDriverDesktop>& service) {
 232   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 233
 234   service_ = service;
 235   gcm_client_->Start();
 236 }
 237
 238 void GCMDriverDesktop::IOWorker::Stop() {
 239   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 240
 241   gcm_client_->Stop();
 242 }
 243
 244 void GCMDriverDesktop::IOWorker::CheckOut() {
 245   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 246
 247   gcm_client_->CheckOut();
 248
 249   // Note that we still need to keep GCMClient instance alive since the
 250   // GCMDriverDesktop may check in again.
 251 }
 252
 253 void GCMDriverDesktop::IOWorker::Register(
 254     const std::string& app_id,
 255     const std::vector<std::string>& sender_ids) {
 256   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 257
 258   gcm_client_->Register(app_id, sender_ids);
 259 }
 260
 261 void GCMDriverDesktop::IOWorker::Unregister(const std::string& app_id) {
 262   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 263
 264   gcm_client_->Unregister(app_id);
 265 }
 266
 267 void GCMDriverDesktop::IOWorker::Send(
 268     const std::string& app_id,
 269     const std::string& receiver_id,
 270     const GCMClient::OutgoingMessage& message) {
 271   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 272
 273   gcm_client_->Send(app_id, receiver_id, message);
 274 }
 275
 276 void GCMDriverDesktop::IOWorker::GetGCMStatistics(bool clear_logs) {
 277   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 278   gcm::GCMClient::GCMStatistics stats;
 279
 280   if (gcm_client_.get()) {
 281     if (clear_logs)
 282       gcm_client_->ClearActivityLogs();
 283     stats = gcm_client_->GetStatistics();
 284   }
 285
 286   ui_thread_->PostTask(
 287       FROM_HERE,
 288       base::Bind(&GCMDriverDesktop::GetGCMStatisticsFinished, service_, stats));
 289 }
 290
 291 void GCMDriverDesktop::IOWorker::SetGCMRecording(bool recording) {
 292   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 293   gcm::GCMClient::GCMStatistics stats;
 294
 295   if (gcm_client_.get()) {
 296     gcm_client_->SetRecording(recording);
 297     stats = gcm_client_->GetStatistics();
 298     stats.gcm_client_created = true;
 299   }
 300
 301   ui_thread_->PostTask(
 302       FROM_HERE,
 303       base::Bind(&GCMDriverDesktop::GetGCMStatisticsFinished, service_, stats));
 304 }
 305
 306 void GCMDriverDesktop::IOWorker::SetAccountsForCheckin(
 307     const std::map<std::string, std::string>& account_tokens) {
 308   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 309
 310   if (gcm_client_.get())
 311     gcm_client_->SetAccountsForCheckin(account_tokens);
 312 }
 313
 314 void GCMDriverDesktop::IOWorker::UpdateAccountMapping(
 315     const AccountMapping& account_mapping) {
 316   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 317
 318   if (gcm_client_.get())
 319     gcm_client_->UpdateAccountMapping(account_mapping);
 320 }
 321
 322 void GCMDriverDesktop::IOWorker::RemoveAccountMapping(
 323     const std::string& account_id) {
 324   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 325
 326   if (gcm_client_.get())
 327     gcm_client_->RemoveAccountMapping(account_id);
 328 }
 329
 330 GCMDriverDesktop::GCMDriverDesktop(
 331     scoped_ptr<GCMClientFactory> gcm_client_factory,
 332     const GCMClient::ChromeBuildInfo& chrome_build_info,
 333     PrefService* prefs,
 334     const base::FilePath& store_path,
 335     const scoped_refptr<net::URLRequestContextGetter>& request_context,
 336     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
 337     const scoped_refptr<base::SequencedTaskRunner>& io_thread,
 338     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner)
 339     : gcm_channel_status_syncer_(
 340           new GCMChannelStatusSyncer(this, prefs, request_context)),
 341       signed_in_(false),
 342       gcm_started_(false),
 343       gcm_enabled_(true),
 344       connected_(false),
 345       ui_thread_(ui_thread),
 346       io_thread_(io_thread),
 347       weak_ptr_factory_(this) {
 348   gcm_enabled_ = gcm_channel_status_syncer_->gcm_enabled();
 349
 350   // Create and initialize the GCMClient. Note that this does not initiate the
 351   // GCM check-in.
 352   io_worker_.reset(new IOWorker(ui_thread, io_thread));
 353   io_thread_->PostTask(
 354       FROM_HERE,
 355       base::Bind(&GCMDriverDesktop::IOWorker::Initialize,
 356                  base::Unretained(io_worker_.get()),
 357                  base::Passed(&gcm_client_factory),
 358                  chrome_build_info,
 359                  store_path,
 360                  request_context,
 361                  blocking_task_runner));
 362 }
 363
 364 GCMDriverDesktop::~GCMDriverDesktop() {
 365 }
 366
 367 void GCMDriverDesktop::Shutdown() {
 368   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 369   GCMDriver::Shutdown();
 370
 371   // Dispose the syncer in order to release the reference to
 372   // URLRequestContextGetter that needs to be done before IOThread gets
 373   // deleted.
 374   gcm_channel_status_syncer_.reset();
 375
 376   io_thread_->DeleteSoon(FROM_HERE, io_worker_.release());
 377 }
 378
 379 void GCMDriverDesktop::OnSignedIn() {
 380   signed_in_ = true;
 381   EnsureStarted();
 382 }
 383
 384 void GCMDriverDesktop::OnSignedOut() {
 385   signed_in_ = false;
 386
 387   // When sign-in enforcement is dropped, we will no longer wipe out the GCM
 388   // data when the user signs out.
 389   if (!GCMDriver::IsAllowedForAllUsers())
 390     Purge();
 391 }
 392
 393 void GCMDriverDesktop::Purge() {
 394   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 395
 396   RemoveCachedData();
 397
 398   io_thread_->PostTask(FROM_HERE,
 399                        base::Bind(&GCMDriverDesktop::IOWorker::CheckOut,
 400                        base::Unretained(io_worker_.get())));
 401 }
 402
 403 void GCMDriverDesktop::AddAppHandler(const std::string& app_id,
 404                                      GCMAppHandler* handler) {
 405   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 406   GCMDriver::AddAppHandler(app_id, handler);
 407
 408    // Ensures that the GCM service is started when there is an interest.
 409   EnsureStarted();
 410 }
 411
 412 void GCMDriverDesktop::RemoveAppHandler(const std::string& app_id) {
 413   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 414   GCMDriver::RemoveAppHandler(app_id);
 415
 416   // Stops the GCM service when no app intends to consume it.
 417   if (app_handlers().empty())
 418     Stop();
 419 }
 420
 421 void GCMDriverDesktop::AddConnectionObserver(GCMConnectionObserver* observer) {
 422   connection_observer_list_.AddObserver(observer);
 423 }
 424
 425 void GCMDriverDesktop::RemoveConnectionObserver(
 426     GCMConnectionObserver* observer) {
 427   connection_observer_list_.RemoveObserver(observer);
 428 }
 429
 430 void GCMDriverDesktop::Enable() {
 431   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 432
 433   if (gcm_enabled_)
 434     return;
 435   gcm_enabled_ = true;
 436
 437   EnsureStarted();
 438 }
 439
 440 void GCMDriverDesktop::Disable() {
 441   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 442
 443   if (!gcm_enabled_)
 444     return;
 445   gcm_enabled_ = false;
 446
 447   Stop();
 448 }
 449
 450 void GCMDriverDesktop::Stop() {
 451   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 452
 453   // No need to stop GCM service if not started yet.
 454   if (!gcm_started_)
 455     return;
 456
 457   gcm_channel_status_syncer_->Stop();
 458
 459   RemoveCachedData();
 460
 461   io_thread_->PostTask(
 462       FROM_HERE,
 463       base::Bind(&GCMDriverDesktop::IOWorker::Stop,
 464                  base::Unretained(io_worker_.get())));
 465 }
 466
 467 void GCMDriverDesktop::RegisterImpl(
 468     const std::string& app_id,
 469     const std::vector<std::string>& sender_ids) {
 470   // Delay the register operation until GCMClient is ready.
 471   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
 472     delayed_task_controller_->AddTask(base::Bind(&GCMDriverDesktop::DoRegister,
 473                                                  weak_ptr_factory_.GetWeakPtr(),
 474                                                  app_id,
 475                                                  sender_ids));
 476     return;
 477   }
 478
 479   DoRegister(app_id, sender_ids);
 480 }
 481
 482 void GCMDriverDesktop::DoRegister(const std::string& app_id,
 483                                   const std::vector<std::string>& sender_ids) {
 484   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 485   if (!HasRegisterCallback(app_id)) {
 486     // The callback could have been removed when the app is uninstalled.
 487     return;
 488   }
 489
 490   io_thread_->PostTask(
 491       FROM_HERE,
 492       base::Bind(&GCMDriverDesktop::IOWorker::Register,
 493                  base::Unretained(io_worker_.get()),
 494                  app_id,
 495                  sender_ids));
 496 }
 497
 498 void GCMDriverDesktop::UnregisterImpl(const std::string& app_id) {
 499   // Delay the unregister operation until GCMClient is ready.
 500   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
 501     delayed_task_controller_->AddTask(
 502         base::Bind(&GCMDriverDesktop::DoUnregister,
 503                    weak_ptr_factory_.GetWeakPtr(),
 504                    app_id));
 505     return;
 506   }
 507
 508   DoUnregister(app_id);
 509 }
 510
 511 void GCMDriverDesktop::DoUnregister(const std::string& app_id) {
 512   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 513
 514   // Ask the server to unregister it. There could be a small chance that the
 515   // unregister request fails. If this occurs, it does not bring any harm since
 516   // we simply reject the messages/events received from the server.
 517   io_thread_->PostTask(
 518       FROM_HERE,
 519       base::Bind(&GCMDriverDesktop::IOWorker::Unregister,
 520                  base::Unretained(io_worker_.get()),
 521                  app_id));
 522 }
 523
 524 void GCMDriverDesktop::SendImpl(const std::string& app_id,
 525                                 const std::string& receiver_id,
 526                                 const GCMClient::OutgoingMessage& message) {
 527   // Delay the send operation until all GCMClient is ready.
 528   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
 529     delayed_task_controller_->AddTask(base::Bind(&GCMDriverDesktop::DoSend,
 530                                                  weak_ptr_factory_.GetWeakPtr(),
 531                                                  app_id,
 532                                                  receiver_id,
 533                                                  message));
 534     return;
 535   }
 536
 537   DoSend(app_id, receiver_id, message);
 538 }
 539
 540 void GCMDriverDesktop::DoSend(const std::string& app_id,
 541                               const std::string& receiver_id,
 542                               const GCMClient::OutgoingMessage& message) {
 543   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 544   io_thread_->PostTask(
 545       FROM_HERE,
 546       base::Bind(&GCMDriverDesktop::IOWorker::Send,
 547                  base::Unretained(io_worker_.get()),
 548                  app_id,
 549                  receiver_id,
 550                  message));
 551 }
 552
 553 GCMClient* GCMDriverDesktop::GetGCMClientForTesting() const {
 554   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 555   return io_worker_ ? io_worker_->gcm_client_for_testing() : NULL;
 556 }
 557
 558 bool GCMDriverDesktop::IsStarted() const {
 559   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 560   return gcm_started_;
 561 }
 562
 563 bool GCMDriverDesktop::IsConnected() const {
 564   return connected_;
 565 }
 566
 567 void GCMDriverDesktop::GetGCMStatistics(
 568     const GetGCMStatisticsCallback& callback,
 569     bool clear_logs) {
 570   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 571   DCHECK(!callback.is_null());
 572
 573   request_gcm_statistics_callback_ = callback;
 574   io_thread_->PostTask(
 575       FROM_HERE,
 576       base::Bind(&GCMDriverDesktop::IOWorker::GetGCMStatistics,
 577                  base::Unretained(io_worker_.get()),
 578                  clear_logs));
 579 }
 580
 581 void GCMDriverDesktop::SetGCMRecording(const GetGCMStatisticsCallback& callback,
 582                                        bool recording) {
 583   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 584
 585   request_gcm_statistics_callback_ = callback;
 586   io_thread_->PostTask(
 587       FROM_HERE,
 588       base::Bind(&GCMDriverDesktop::IOWorker::SetGCMRecording,
 589                  base::Unretained(io_worker_.get()),
 590                  recording));
 591 }
 592
 593 void GCMDriverDesktop::UpdateAccountMapping(
 594     const AccountMapping& account_mapping) {
 595   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 596
 597   io_thread_->PostTask(
 598       FROM_HERE,
 599       base::Bind(&GCMDriverDesktop::IOWorker::UpdateAccountMapping,
 600                  base::Unretained(io_worker_.get()),
 601                  account_mapping));
 602 }
 603
 604 void GCMDriverDesktop::RemoveAccountMapping(const std::string& account_id) {
 605   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 606
 607   io_thread_->PostTask(
 608       FROM_HERE,
 609       base::Bind(&GCMDriverDesktop::IOWorker::RemoveAccountMapping,
 610                  base::Unretained(io_worker_.get()),
 611                  account_id));
 612 }
 613
 614 void GCMDriverDesktop::SetAccountsForCheckin(
 615     const std::map<std::string, std::string>& account_tokens) {
 616   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 617
 618   io_thread_->PostTask(
 619       FROM_HERE,
 620       base::Bind(&GCMDriverDesktop::IOWorker::SetAccountsForCheckin,
 621                  base::Unretained(io_worker_.get()),
 622                  account_tokens));
 623 }
 624
 625 GCMClient::Result GCMDriverDesktop::EnsureStarted() {
 626   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 627
 628   if (gcm_started_)
 629     return GCMClient::SUCCESS;
 630
 631   if (!gcm_enabled_)
 632     return GCMClient::GCM_DISABLED;
 633
 634   // Have any app requested the service?
 635   if (app_handlers().empty())
 636     return GCMClient::UNKNOWN_ERROR;
 637
 638   if (!signed_in_ && !GCMDriver::IsAllowedForAllUsers())
 639     return GCMClient::NOT_SIGNED_IN;
 640
 641   DCHECK(!delayed_task_controller_);
 642   delayed_task_controller_.reset(new GCMDelayedTaskController);
 643
 644   // Polling for channel status is only needed when GCM is supported for all
 645   // users.
 646   if (GCMDriver::IsAllowedForAllUsers())
 647     gcm_channel_status_syncer_->EnsureStarted();
 648
 649   // Note that we need to pass weak pointer again since the existing weak
 650   // pointer in IOWorker might have been invalidated when check-out occurs.
 651   io_thread_->PostTask(
 652       FROM_HERE,
 653       base::Bind(&GCMDriverDesktop::IOWorker::Start,
 654                  base::Unretained(io_worker_.get()),
 655                  weak_ptr_factory_.GetWeakPtr()));
 656
 657   gcm_started_ = true;
 658   return GCMClient::SUCCESS;
 659 }
 660
 661 void GCMDriverDesktop::RemoveCachedData() {
 662   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 663   // Remove all the queued tasks since they no longer make sense after
 664   // GCM service is stopped.
 665   weak_ptr_factory_.InvalidateWeakPtrs();
 666
 667   gcm_started_ = false;
 668   delayed_task_controller_.reset();
 669   ClearCallbacks();
 670 }
 671
 672 void GCMDriverDesktop::MessageReceived(
 673     const std::string& app_id,
 674     const GCMClient::IncomingMessage& message) {
 675   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 676
 677   // Drop the event if the service has been stopped.
 678   if (!gcm_started_)
 679     return;
 680
 681   GetAppHandler(app_id)->OnMessage(app_id, message);
 682 }
 683
 684 void GCMDriverDesktop::MessagesDeleted(const std::string& app_id) {
 685   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 686
 687   // Drop the event if the service has been stopped.
 688   if (!gcm_started_)
 689     return;
 690
 691   GetAppHandler(app_id)->OnMessagesDeleted(app_id);
 692 }
 693
 694 void GCMDriverDesktop::MessageSendError(
 695     const std::string& app_id,
 696     const GCMClient::SendErrorDetails& send_error_details) {
 697   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 698
 699   // Drop the event if the service has been stopped.
 700   if (!gcm_started_)
 701     return;
 702
 703   GetAppHandler(app_id)->OnSendError(app_id, send_error_details);
 704 }
 705
 706 void GCMDriverDesktop::SendAcknowledged(const std::string& app_id,
 707                                         const std::string& message_id) {
 708   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 709
 710   // Drop the event if the service has been stopped.
 711   if (!gcm_started_)
 712     return;
 713
 714   GetAppHandler(app_id)->OnSendAcknowledged(app_id, message_id);
 715 }
 716
 717 void GCMDriverDesktop::GCMClientReady() {
 718   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 719
 720   delayed_task_controller_->SetReady();
 721 }
 722
 723 void GCMDriverDesktop::OnConnected(const net::IPEndPoint& ip_endpoint) {
 724   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 725
 726   connected_ = true;
 727
 728   // Drop the event if the service has been stopped.
 729   if (!gcm_started_)
 730     return;
 731
 732   FOR_EACH_OBSERVER(GCMConnectionObserver,
 733                     connection_observer_list_,
 734                     OnConnected(ip_endpoint));
 735 }
 736
 737 void GCMDriverDesktop::OnDisconnected() {
 738   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 739
 740   connected_ = false;
 741
 742   // Drop the event if the service has been stopped.
 743   if (!gcm_started_)
 744     return;
 745
 746   FOR_EACH_OBSERVER(
 747       GCMConnectionObserver, connection_observer_list_, OnDisconnected());
 748 }
 749
 750 void GCMDriverDesktop::GetGCMStatisticsFinished(
 751     const GCMClient::GCMStatistics& stats) {
 752   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 753
 754   // Normally request_gcm_statistics_callback_ would not be null.
 755   if (!request_gcm_statistics_callback_.is_null())
 756     request_gcm_statistics_callback_.Run(stats);
 757   else
 758     LOG(WARNING) << "request_gcm_statistics_callback_ is NULL.";
 759 }
 760
 761 }  // namespace gcm
 762