[GCM] Support registration before unregistration finishes

components/gcm_driver/gcm_driver.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.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 
 namespace gcm {
 
 namespace {
 const char kGCMFieldTrialName[] = "GCM";
 const char kGCMFieldTrialEnabledGroupName[] = "Enabled";
 }  // namespace
 
 // static
 bool GCMDriver::IsAllowedForAllUsers() {
   std::string group_name =
       base::FieldTrialList::FindFullName(kGCMFieldTrialName);
   return group_name == kGCMFieldTrialEnabledGroupName;
 }
 
-GCMDriver::GCMDriver() {
+GCMDriver::GCMDriver() : weak_ptr_factory_(this) {
 }
 
 GCMDriver::~GCMDriver() {
 }
 
 void GCMDriver::Register(const std::string& app_id,
                          const std::vector<std::string>& sender_ids,
                          const RegisterCallback& callback) {
   DCHECK(!app_id.empty());
   DCHECK(!sender_ids.empty());
   DCHECK(!callback.is_null());
 
   GCMClient::Result result = EnsureStarted();
   if (result != GCMClient::SUCCESS) {
     callback.Run(std::string(), result);
     return;
   }
 
-  // If previous un/register operation is still in progress, bail out.
-  if (IsAsyncOperationPending(app_id)) {
+  // If previous register operation is still in progress, bail out.
+  if (register_callbacks_.find(app_id) != register_callbacks_.end()) {
     callback.Run(std::string(), GCMClient::ASYNC_OPERATION_PENDING);
     return;
   }
 
   // Normalize the sender IDs by making them sorted.
   std::vector<std::string> normalized_sender_ids = sender_ids;
   std::sort(normalized_sender_ids.begin(), normalized_sender_ids.end());
 
   register_callbacks_[app_id] = callback;
 
+  // If previous unregister operation is still in progress, wait until it
+  // finishes. We don't want to throw ASYNC_OPERATION_PENDING when the user
+  // uninstalls an app (ungistering) and then reinstalls the app again
+  // (registering).
+  std::map<std::string, UnregisterCallback>::iterator unregister_iter =
+      unregister_callbacks_.find(app_id);
+  if (unregister_iter != unregister_callbacks_.end()) {
+    // Replace the original unregister callback with an intermediate callback
+    // that will invoke the original unregister callback and trigger the pending
+    // registration after the unregistration finishes.
+    // Note that some parameters to RegisterAfterUnregister are specified here
+    // when the callback is created (base::Bind supports the partial binding
+    // of parameters).
+    unregister_iter->second = base::Bind(
+        &GCMDriver::RegisterAfterUnregister,
+        weak_ptr_factory_.GetWeakPtr(),
+        app_id,
+        normalized_sender_ids,
+        unregister_iter->second);
+    return;
+  }
+
   RegisterImpl(app_id, normalized_sender_ids);
 }
 
 void GCMDriver::Unregister(const std::string& app_id,
                            const UnregisterCallback& callback) {
   DCHECK(!app_id.empty());
   DCHECK(!callback.is_null());
 
   GCMClient::Result result = EnsureStarted();
   if (result != GCMClient::SUCCESS) {
     callback.Run(result);
     return;
   }
 
   // If previous un/register operation is still in progress, bail out.
-  if (IsAsyncOperationPending(app_id)) {
+  if (register_callbacks_.find(app_id) != register_callbacks_.end() ||
+      unregister_callbacks_.find(app_id) != unregister_callbacks_.end()) {
     callback.Run(GCMClient::ASYNC_OPERATION_PENDING);
     return;
   }
 
   unregister_callbacks_[app_id] = callback;
 
   UnregisterImpl(app_id);
 }
 
 void GCMDriver::Send(const std::string& app_id,
@@ skipping 107 matching lines @@
 bool GCMDriver::HasRegisterCallback(const std::string& app_id) {
   return register_callbacks_.find(app_id) != register_callbacks_.end();
 }
 
 void GCMDriver::ClearCallbacks() {
   register_callbacks_.clear();
   unregister_callbacks_.clear();
   send_callbacks_.clear();
 }
 
-bool GCMDriver::IsAsyncOperationPending(const std::string& app_id) const {
-  return register_callbacks_.find(app_id) != register_callbacks_.end() ||
-         unregister_callbacks_.find(app_id) != unregister_callbacks_.end();
+void GCMDriver::RegisterAfterUnregister(
+    const std::string& app_id,
+    const std::vector<std::string>& normalized_sender_ids,
+    const UnregisterCallback& unregister_callback,
+    GCMClient::Result result) {
+  // Invoke the original unregister callback.
+  unregister_callback.Run(result);
+
+  // Trigger the pending registration.
+  DCHECK(register_callbacks_.find(app_id) != register_callbacks_.end());
+  RegisterImpl(app_id, normalized_sender_ids);
 }
 
 }  // namespace gcm