Push API: Fix registration failing because app handler is missing

chrome/browser/services/gcm/push_messaging_service_impl.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 "chrome/browser/services/gcm/push_messaging_service_impl.h"
 
 #include <bitset>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 91 matching lines @@
   if (count <= 0)
     return;
 
   // Create the GCMProfileService, and hence instantiate this class.
   GCMProfileService* gcm_service =
       GCMProfileServiceFactory::GetForProfile(profile);
   PushMessagingServiceImpl* push_service =
       static_cast<PushMessagingServiceImpl*>(
           gcm_service->push_messaging_service());
 
-  push_service->IncreasePushRegistrationCount(count);
+  push_service->IncreasePushRegistrationCount(count, false /* is_pending */);
 }
 
 PushMessagingServiceImpl::PushMessagingServiceImpl(
     GCMProfileService* gcm_profile_service,
     Profile* profile)
     : gcm_profile_service_(gcm_profile_service),
       profile_(profile),
       push_registration_count_(0),
+      pending_push_registration_count_(0),
       weak_factory_(this) {
 }
 
 PushMessagingServiceImpl::~PushMessagingServiceImpl() {
   // TODO(johnme): If it's possible for this to be destroyed before GCMDriver,
   // then we should call RemoveAppHandler.
 }
 
-void PushMessagingServiceImpl::IncreasePushRegistrationCount(int add) {
+void PushMessagingServiceImpl::IncreasePushRegistrationCount(int add,
+                                                             bool is_pending) {
   DCHECK(add > 0);
-  if (push_registration_count_ == 0) {
+  if (push_registration_count_ + pending_push_registration_count_ == 0) {
     gcm_profile_service_->driver()->AddAppHandler(
         kPushMessagingApplicationIdPrefix, this);
   }
-  push_registration_count_ += add;
-  profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
-                                   push_registration_count_);
+  if (is_pending) {
+    pending_push_registration_count_ += add;
+  } else {
+    push_registration_count_ += add;
+    profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
+                                     push_registration_count_);
+  }
 }
 
-void PushMessagingServiceImpl::DecreasePushRegistrationCount(int subtract) {
+void PushMessagingServiceImpl::DecreasePushRegistrationCount(int subtract,
+                                                             bool was_pending) {
   DCHECK(subtract > 0);
-  push_registration_count_ -= subtract;
-  DCHECK(push_registration_count_ >= 0);
-  profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
-                                   push_registration_count_);
-  if (push_registration_count_ == 0) {
+  if (was_pending) {
+    pending_push_registration_count_ -= subtract;
+    DCHECK(pending_push_registration_count_ >= 0);
+  } else {
+    push_registration_count_ -= subtract;
+    DCHECK(push_registration_count_ >= 0);
+    profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
+                                     push_registration_count_);
+  }
+  if (push_registration_count_ + pending_push_registration_count_ == 0) {
     gcm_profile_service_->driver()->RemoveAppHandler(
         kPushMessagingApplicationIdPrefix);
   }
 }
 
 bool PushMessagingServiceImpl::CanHandle(const std::string& app_id) const {
   return PushMessagingApplicationId::Parse(app_id).IsValid();
 }
 
 void PushMessagingServiceImpl::ShutdownHandler() {
@@ skipping 259 matching lines @@
     const content::PushMessagingService::RegisterCallback& callback) {
   if (!gcm_profile_service_->driver()) {
     NOTREACHED() << "There is no GCMDriver. Has GCMProfileService shut down?";
     return;
   }
 
   PushMessagingApplicationId application_id = PushMessagingApplicationId(
       requesting_origin, service_worker_registration_id);
   DCHECK(application_id.IsValid());
 
-  if (push_registration_count_ >= kMaxRegistrations) {
+  if (push_registration_count_ + pending_push_registration_count_
+      >= kMaxRegistrations) {
     RegisterEnd(callback,
                 std::string(),
                 content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
     return;
   }
 
   content::RenderFrameHost* render_frame_host =
       content::RenderFrameHost::FromID(renderer_id, render_frame_id);
   if (!render_frame_host)
     return;
@@ skipping 56 matching lines @@
   GURL embedding_origin = requesting_origin;
   blink::WebPushPermissionStatus permission_status =
       PushMessagingServiceImpl::GetPermissionStatus(requesting_origin,
                                                     embedding_origin);
   if (permission_status != blink::WebPushPermissionStatusGranted) {
     RegisterEnd(register_callback, std::string(),
                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
+  IncreasePushRegistrationCount(1, true /* is_pending */);
   std::vector<std::string> sender_ids(1, sender_id);
   gcm_profile_service_->driver()->Register(
       application_id.ToString(), sender_ids,
       base::Bind(&PushMessagingServiceImpl::DidRegister,
                  weak_factory_.GetWeakPtr(), register_callback));
 }
 
 blink::WebPushPermissionStatus PushMessagingServiceImpl::GetPermissionStatus(
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
   PushMessagingPermissionContext* permission_context =
       PushMessagingPermissionContextFactory::GetForProfile(profile_);
   return ToPushPermission(permission_context->GetPermissionStatus(
       requesting_origin, embedding_origin));
 }
 
 void PushMessagingServiceImpl::RegisterEnd(
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
     content::PushRegistrationStatus status) {
   callback.Run(registration_id, status);
-  if (status == content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE)
-    IncreasePushRegistrationCount(1);
 }
 
 void PushMessagingServiceImpl::DidRegister(
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
     GCMClient::Result result) {
   content::PushRegistrationStatus status =
-      result == GCMClient::SUCCESS
-          ? content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE
-          : content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
+      content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
+  if (result == GCMClient::SUCCESS) {
+    status = content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE;
+    IncreasePushRegistrationCount(1, false /* is_pending */);
+  }
   RegisterEnd(callback, registration_id, status);
+  DecreasePushRegistrationCount(1, true /* was_pending */);
 }
 
 void PushMessagingServiceImpl::DidRequestPermission(
     const PushMessagingApplicationId& application_id,
     const std::string& sender_id,
     const content::PushMessagingService::RegisterCallback& register_callback,
     bool allow) {
   if (!allow) {
     RegisterEnd(register_callback,
                 std::string(),
                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   // The GCMDriver could be NULL if GCMProfileService has been shut down.
   if (!gcm_profile_service_->driver())
     return;
 
+  IncreasePushRegistrationCount(1, true /* is_pending */);
   std::vector<std::string> sender_ids(1, sender_id);
-
   gcm_profile_service_->driver()->Register(
       application_id.ToString(),
       sender_ids,
       base::Bind(&PushMessagingServiceImpl::DidRegister,
                  weak_factory_.GetWeakPtr(),
                  register_callback));
 }
 
 void PushMessagingServiceImpl::Unregister(
     const GURL& requesting_origin,
@@ skipping 40 matching lines @@
       callback.Run(content::PUSH_UNREGISTRATION_STATUS_UNKNOWN_ERROR);
       break;
     default:
       NOTREACHED() << "Unexpected GCMClient::Result value.";
       callback.Run(content::PUSH_UNREGISTRATION_STATUS_UNKNOWN_ERROR);
       break;
     }
   }
 
   if (result == GCMClient::SUCCESS)
-    DecreasePushRegistrationCount(1);
+    DecreasePushRegistrationCount(1, false /* was_pending */);
 }
 
 bool PushMessagingServiceImpl::HasPermission(const GURL& origin) {
   gcm::PushMessagingPermissionContext* permission_context =
       gcm::PushMessagingPermissionContextFactory::GetForProfile(profile_);
   DCHECK(permission_context);
 
   return permission_context->GetPermissionStatus(origin, origin) ==
       CONTENT_SETTING_ALLOW;
 }
 
 }  // namespace gcm