[GCM] Handling connection events in GCMAccountTracker

components/gcm_driver/gcm_driver_desktop.cc

 // 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.
 
 #include "components/gcm_driver/gcm_driver_desktop.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 329 matching lines @@
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
     const scoped_refptr<base::SequencedTaskRunner>& io_thread,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner)
     : gcm_channel_status_syncer_(
           new GCMChannelStatusSyncer(this, prefs, request_context)),
       signed_in_(false),
       gcm_started_(false),
       gcm_enabled_(true),
       connected_(false),
+      account_mapper_(new GCMAccountMapper(this)),
       ui_thread_(ui_thread),
       io_thread_(io_thread),
       weak_ptr_factory_(this) {
   gcm_enabled_ = gcm_channel_status_syncer_->gcm_enabled();
 
   // Create and initialize the GCMClient. Note that this does not initiate the
   // GCM check-in.
   io_worker_.reset(new IOWorker(ui_thread, io_thread));
   io_thread_->PostTask(
       FROM_HERE,
@@ skipping 24 matching lines @@
 void GCMDriverDesktop::OnSignedIn() {
   signed_in_ = true;
   EnsureStarted();
 }
 
 void GCMDriverDesktop::OnSignedOut() {
   signed_in_ = false;
 
   // When sign-in enforcement is not dropped, we will stop the GCM connection
   // when the user signs out.
-  if (!GCMDriver::IsAllowedForAllUsers())
+  if (!GCMDriver::IsAllowedForAllUsers()) {
     Stop();
+  }
 }
 
 void GCMDriverDesktop::Purge() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   RemoveCachedData();
 
   io_thread_->PostTask(FROM_HERE,
                        base::Bind(&GCMDriverDesktop::IOWorker::CheckOut,
                        base::Unretained(io_worker_.get())));
 }
 
 void GCMDriverDesktop::AddAppHandler(const std::string& app_id,
                                      GCMAppHandler* handler) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   GCMDriver::AddAppHandler(app_id, handler);
 
    // Ensures that the GCM service is started when there is an interest.
   EnsureStarted();
 }
 
 void GCMDriverDesktop::RemoveAppHandler(const std::string& app_id) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   GCMDriver::RemoveAppHandler(app_id);
 
-  // Stops the GCM service when no app intends to consume it.
-  if (app_handlers().empty())
+  // Stops the GCM service when no app intends to consume it. Stop function will
+  // remove the last app handler - account mapper.
+  if (app_handlers().size() == 1) {
     Stop();
+  }
 }
 
 void GCMDriverDesktop::AddConnectionObserver(GCMConnectionObserver* observer) {
   connection_observer_list_.AddObserver(observer);
 }
 
 void GCMDriverDesktop::RemoveConnectionObserver(
     GCMConnectionObserver* observer) {
   connection_observer_list_.RemoveObserver(observer);
 }
@@ skipping 20 matching lines @@
 
 void GCMDriverDesktop::Stop() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // No need to stop GCM service if not started yet.
   if (!gcm_started_)
     return;
 
   gcm_channel_status_syncer_->Stop();
 
+  account_mapper_->ShutdownHandler();
+  GCMDriver::RemoveAppHandler(kGCMAccountMapperAppId);
+
   RemoveCachedData();
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Stop,
                  base::Unretained(io_worker_.get())));
 }
 
 void GCMDriverDesktop::RegisterImpl(
     const std::string& app_id,
@@ skipping 139 matching lines @@
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::RemoveAccountMapping,
                  base::Unretained(io_worker_.get()),
                  account_id));
 }
 
 void GCMDriverDesktop::SetAccountTokens(
     const std::vector<GCMClient::AccountTokenInfo>& account_tokens) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
+  account_mapper_->SetAccountTokens(account_tokens);
+
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::SetAccountTokens,
                  base::Unretained(io_worker_.get()),
                  account_tokens));
 }
 
 GCMClient::Result GCMDriverDesktop::EnsureStarted() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
@@ skipping 86 matching lines @@
   if (!gcm_started_)
     return;
 
   GetAppHandler(app_id)->OnSendAcknowledged(app_id, message_id);
 }
 
 void GCMDriverDesktop::GCMClientReady(
     const std::vector<AccountMapping>& account_mappings) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
+  account_mapper_->Initialize(account_mappings);
+
   delayed_task_controller_->SetReady();
 }
 
 void GCMDriverDesktop::OnConnected(const net::IPEndPoint& ip_endpoint) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   connected_ = true;
 
   // Drop the event if the service has been stopped.
   if (!gcm_started_)
@@ skipping 23 matching lines @@
 
   // Normally request_gcm_statistics_callback_ would not be null.
   if (!request_gcm_statistics_callback_.is_null())
     request_gcm_statistics_callback_.Run(stats);
   else
     LOG(WARNING) << "request_gcm_statistics_callback_ is NULL.";
 }
 
 }  // namespace gcm