Cleanup PushMessagingAppIdentifier

chrome/browser/push_messaging/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/push_messaging/push_messaging_service_impl.h"
 
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
@@ skipping 127 matching lines @@
     DCHECK(push_registration_count_ >= 0);
     profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
                                      push_registration_count_);
   }
   if (push_registration_count_ + pending_push_registration_count_ == 0) {
     GetGCMDriver()->RemoveAppHandler(kPushMessagingAppIdentifierPrefix);
   }
 }
 
 bool PushMessagingServiceImpl::CanHandle(const std::string& app_id) const {
-  return PushMessagingAppIdentifier::Get(profile_, app_id).IsValid();
+  return !PushMessagingAppIdentifier::Get(profile_, app_id).is_null();
 }
 
 void PushMessagingServiceImpl::ShutdownHandler() {
   // Shutdown() should come before and it removes us from the list of app
   // handlers of gcm::GCMDriver so this shouldn't ever been called.
   NOTREACHED();
 }
 
 // OnMessage methods -----------------------------------------------------------
 
 void PushMessagingServiceImpl::OnMessage(
     const std::string& app_id,
     const gcm::GCMClient::IncomingMessage& message) {
   base::Closure message_handled_closure =
       message_callback_for_testing_.is_null() ? base::Bind(&base::DoNothing)
                                               : message_callback_for_testing_;
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::Get(profile_, app_id);
   // Drop message and unregister if app_id was unknown (maybe recently deleted).
-  if (!app_identifier.IsValid()) {
+  if (app_identifier.is_null()) {
     DeliverMessageCallback(app_id, GURL::EmptyGURL(), -1, message,
                            message_handled_closure,
                            content::PUSH_DELIVERY_STATUS_UNKNOWN_APP_ID);
     return;
   }
   // Drop message and unregister if |origin| has lost push permission.
   if (!HasPermission(app_identifier.origin())) {
     DeliverMessageCallback(app_id, app_identifier.origin(),
                            app_identifier.service_worker_registration_id(),
                            message, message_handled_closure,
@@ skipping 118 matching lines @@
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     int renderer_id,
     int render_frame_id,
     bool user_visible,
     const content::PushMessagingService::RegisterCallback& callback) {
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::Generate(requesting_origin,
                                            service_worker_registration_id);
-  DCHECK(app_identifier.IsValid());
 
   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 =
@@ skipping 37 matching lines @@
 
 void PushMessagingServiceImpl::RegisterFromWorker(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     bool user_visible,
     const content::PushMessagingService::RegisterCallback& register_callback) {
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::Generate(requesting_origin,
                                            service_worker_registration_id);
-  DCHECK(app_identifier.IsValid());
 
   if (profile_->GetPrefs()->GetInteger(
           prefs::kPushMessagingRegistrationCount) >= kMaxRegistrations) {
     RegisterEnd(register_callback, std::string(),
                 content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
     return;
   }
 
   // TODO(peter): Consider |user_visible| when getting the permission status
   // for registering from a worker.
@@ skipping 40 matching lines @@
 void PushMessagingServiceImpl::DidRegister(
     const PushMessagingAppIdentifier& app_identifier,
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
     gcm::GCMClient::Result result) {
   content::PushRegistrationStatus status =
       content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
   switch (result) {
     case gcm::GCMClient::SUCCESS:
       status = content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE;
-      app_identifier.PersistToDisk(profile_);
+      app_identifier.PersistToPrefs(profile_);
       IncreasePushRegistrationCount(1, false /* is_pending */);
       break;
     case gcm::GCMClient::INVALID_PARAMETER:
     case gcm::GCMClient::GCM_DISABLED:
     case gcm::GCMClient::ASYNC_OPERATION_PENDING:
     case gcm::GCMClient::SERVER_ERROR:
     case gcm::GCMClient::UNKNOWN_ERROR:
       status = content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
       break;
     case gcm::GCMClient::NETWORK_ERROR:
@@ skipping 29 matching lines @@
 
 // Unregister methods ----------------------------------------------------------
 
 void PushMessagingServiceImpl::Unregister(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     const content::PushMessagingService::UnregisterCallback& callback) {
   PushMessagingAppIdentifier app_identifier = PushMessagingAppIdentifier::Get(
       profile_, requesting_origin, service_worker_registration_id);
-  if (!app_identifier.IsValid()) {
+  if (app_identifier.is_null()) {
     if (!callback.is_null()) {
       callback.Run(
           content::PUSH_UNREGISTRATION_STATUS_SUCCESS_WAS_NOT_REGISTERED);
     }
     return;
   }
 
   Unregister(app_identifier.app_id(), sender_id, callback);
 }
 
 void PushMessagingServiceImpl::Unregister(
     const std::string& app_id,
     const std::string& sender_id,
     const content::PushMessagingService::UnregisterCallback& callback) {
   // Delete the mapping for this app_id, to guarantee that no messages get
   // delivered in future (even if unregistration fails).
   // TODO(johnme): Instead of deleting these app ids, store them elsewhere, and
   // retry unregistration if it fails due to network errors (crbug.com/465399).
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::Get(profile_, app_id);
-  bool was_registered = app_identifier.IsValid();
+  bool was_registered = !app_identifier.is_null();
   if (was_registered)
-    app_identifier.DeleteFromDisk(profile_);
+    app_identifier.DeleteFromPrefs(profile_);
 
   const auto& unregister_callback =
       base::Bind(&PushMessagingServiceImpl::DidUnregister,
                  weak_factory_.GetWeakPtr(),
                  was_registered, callback);
 #if defined(OS_ANDROID)
   // On Android the backend is different, and requires the original sender_id.
   // UnregisterBecausePermissionRevoked sometimes calls us with an empty one.
   if (sender_id.empty())
     unregister_callback.Run(gcm::GCMClient::INVALID_PARAMETER);
@@ skipping 130 matching lines @@
       CONTENT_SETTING_ALLOW;
 }
 
 gcm::GCMDriver* PushMessagingServiceImpl::GetGCMDriver() const {
   gcm::GCMProfileService* gcm_profile_service =
       gcm::GCMProfileServiceFactory::GetForProfile(profile_);
   CHECK(gcm_profile_service);
   CHECK(gcm_profile_service->driver());
   return gcm_profile_service->driver();
 }