[GCM] Adding registration ID request and tests to GCM Account Mapper

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"
@@ skipping 29 matching lines @@
     : 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,
-    const std::string& registration_id) {
+    const std::vector<AccountMapping>& account_mappings) {
   DCHECK(!initialized_);
   initialized_ = true;
-  registration_id_ = registration_id;
-
   accounts_ = account_mappings;
-
   gcm_driver_->AddAppHandler(kGCMAccountMapperAppId, this);
-
-  // TODO(fgorski): if no registration ID, get registration ID.
+  GetRegistration();
 }
 
 void GCMAccountMapper::SetAccountTokens(
     const std::vector<GCMClient::AccountTokenInfo> account_tokens) {
-  DCHECK(initialized_);
+  // 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_)
+      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();
   }
 
   // Update the internal collection of mappings with the new tokens.
   for (std::vector<GCMClient::AccountTokenInfo>::const_iterator token_iter =
@@ skipping 131 matching lines @@
     account_mapping_it->last_message_id.clear();
 
     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();
+}
+
 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.
   if (account_mapping.status != AccountMapping::REMOVING) {
     account_mapping.status = AccountMapping::REMOVING;
@@ skipping 23 matching lines @@
   }
 
   gcm_driver_->Send(kGCMAccountMapperAppId,
                     kGCMAccountMapperSenderId,
                     outgoing_message,
                     base::Bind(&GCMAccountMapper::OnSendFinished,
                                weak_ptr_factory_.GetWeakPtr(),
                                account_mapping.account_id));
 }
 
-
 void GCMAccountMapper::OnSendFinished(const std::string& account_id,
                                       const std::string& message_id,
                                       GCMClient::Result result) {
   // TODO(fgorski): Add another attempt, in case the QUEUE is not full.
   if (result != GCMClient::SUCCESS)
     return;
 
   AccountMapping* account_mapping = FindMappingByAccountId(account_id);
   DCHECK(account_mapping);
 
   // If we are dealing with account with status NEW, it is the first time
   // mapping, and we should mark it as ADDING.
   if (account_mapping->status == AccountMapping::NEW) {
     account_mapping->status = AccountMapping::ADDING;
     account_mapping->status_change_timestamp = clock_->Now();
   }
 
   account_mapping->last_message_id = message_id;
 
   gcm_driver_->UpdateAccountMapping(*account_mapping);
 }
 
+void GCMAccountMapper::GetRegistration() {
+  DCHECK(registration_id_.empty());
+  std::vector<std::string> sender_ids;
+  sender_ids.push_back(kGCMAccountMapperSenderId);
+  gcm_driver_->Register(kGCMAccountMapperAppId,
+                        sender_ids,
+                        base::Bind(&GCMAccountMapper::OnRegisterFinished,
+                                   weak_ptr_factory_.GetWeakPtr()));
+}
+
+void GCMAccountMapper::OnRegisterFinished(const std::string& registration_id,
+                                          GCMClient::Result result) {
+  if (result == GCMClient::SUCCESS)
+    registration_id_ = registration_id;
+
+  if (IsReady()) {
+    if (!pending_account_tokens_.empty()) {
+      SetAccountTokens(pending_account_tokens_);
+      pending_account_tokens_.clear();
+    }
+  }
+}
+
 bool GCMAccountMapper::CanTriggerUpdate(
     const base::Time& last_update_time) const {
   return last_update_time +
              base::TimeDelta::FromHours(kGCMUpdateIntervalHours -
                                         kGCMUpdateEarlyStartHours) <
          clock_->Now();
 }
 
 bool GCMAccountMapper::IsLastStatusChangeOlderThanTTL(
     const AccountMapping& account_mapping) const {
@@ skipping 25 matching lines @@
   }
 
   return accounts_.end();
 }
 
 void GCMAccountMapper::SetClockForTesting(scoped_ptr<base::Clock> clock) {
   clock_ = clock.Pass();
 }
 
 }  // namespace gcm