[GCM] Handling connection events in GCMAccountTracker

components/gcm_driver/gcm_account_mapper.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_account_mapper.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "components/gcm_driver/gcm_driver_desktop.h"
 #include "google_apis/gcm/engine/gcm_store.h"
 
 namespace gcm {
 
 namespace {
 
 const char kGCMAccountMapperSenderId[] = "745476177629";
-const char kGCMAccountMapperAppId[] = "com.google.android.gms";
 const int kGCMAddMappingMessageTTL = 30 * 60;  // 0.5 hours in seconds.
 const int kGCMRemoveMappingMessageTTL = 24 * 60 * 60;  // 1 day in seconds.
 const int kGCMUpdateIntervalHours = 24;
 // Because adding an account mapping dependents on a fresh OAuth2 token, we
 // allow the update to happen earlier than update due time, if it is within
 // the early start time to take advantage of that token.
 const int kGCMUpdateEarlyStartHours = 6;
 const char kRegistrationIdMessgaeKey[] = "id";
 const char kTokenMessageKey[] = "t";
 const char kAccountMessageKey[] = "a";
 const char kRemoveAccountKey[] = "r";
 const char kRemoveAccountValue[] = "1";
 
 std::string GenerateMessageID() {
   return base::GenerateGUID();
 }
 
 }  // namespace
 
+const char kGCMAccountMapperAppId[] = "com.google.android.gms";
+
 GCMAccountMapper::GCMAccountMapper(GCMDriver* gcm_driver)
     : gcm_driver_(gcm_driver),
       clock_(new base::DefaultClock),
       initialized_(false),
       weak_ptr_factory_(this) {
 }
 
 GCMAccountMapper::~GCMAccountMapper() {
 }
 
 void GCMAccountMapper::Initialize(
     const std::vector<AccountMapping>& account_mappings) {
-  DCHECK(!initialized_);
   initialized_ = true;
   accounts_ = account_mappings;
   gcm_driver_->AddAppHandler(kGCMAccountMapperAppId, this);
   GetRegistration();
 }
 
 void GCMAccountMapper::SetAccountTokens(
     const std::vector<GCMClient::AccountTokenInfo>& account_tokens) {
+  DVLOG(1) << "GCMAccountMapper::SetAccountTokens called with "
+           << account_tokens.size() << " accounts.";
+
   // If account mapper is not ready to handle tasks yet, save the latest
   // account tokens and return.
   if (!IsReady()) {
     pending_account_tokens_ = account_tokens;
     // If mapper is initialized, but still does not have registration ID,
     // maybe the registration gave up. Retrying in case.
-    if (initialized_)
+    if (initialized_ && gcm_driver_->IsStarted())
       GetRegistration();
     return;
   }
 
   // Start from removing the old tokens, from all of the known accounts.
   for (AccountMappings::iterator iter = accounts_.begin();
        iter != accounts_.end();
        ++iter) {
     iter->access_token.clear();
   }
@@ skipping 50 matching lines @@
           (mappings_iter->status == AccountMapping::MAPPED &&
            CanTriggerUpdate(mappings_iter->status_change_timestamp))) {
         mappings_iter->last_message_id.clear();
         SendAddMappingMessage(*mappings_iter);
       }
     }
   }
 }
 
 void GCMAccountMapper::ShutdownHandler() {
-  gcm_driver_->RemoveAppHandler(kGCMAccountMapperAppId);
+  initialized_ = false;
+  accounts_.clear();
+  registration_id_.clear();
 }
 
 void GCMAccountMapper::OnMessage(const std::string& app_id,
                                  const GCMClient::IncomingMessage& message) {
   // Account message does not expect messages right now.
 }
 
 void GCMAccountMapper::OnMessagesDeleted(const std::string& app_id) {
   // Account message does not expect messages right now.
 }
@@ skipping 64 matching lines @@
 
     gcm_driver_->UpdateAccountMapping(*account_mapping_it);
   }
 }
 
 bool GCMAccountMapper::CanHandle(const std::string& app_id) const {
   return app_id.compare(kGCMAccountMapperAppId) == 0;
 }
 
 bool GCMAccountMapper::IsReady() {
-  return initialized_ && !registration_id_.empty();
+  return initialized_ && gcm_driver_->IsStarted() && !registration_id_.empty();
 }
 
 void GCMAccountMapper::SendAddMappingMessage(AccountMapping& account_mapping) {
   CreateAndSendMessage(account_mapping);
 }
 
 void GCMAccountMapper::SendRemoveMappingMessage(
     AccountMapping& account_mapping) {
   // We want to persist an account that is being removed as quickly as possible
   // as well as clean up the last message information.
@@ skipping 115 matching lines @@
   }
 
   return accounts_.end();
 }
 
 void GCMAccountMapper::SetClockForTesting(scoped_ptr<base::Clock> clock) {
   clock_ = clock.Pass();
 }
 
 }  // namespace gcm