Consistently handle persistent notification ids as int64_t

content/child/notifications/notification_manager.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 "content/child/notifications/notification_manager.h"
 
 #include <cmath>
 
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "content/child/notifications/notification_data_conversions.h"
 #include "content/child/notifications/notification_dispatcher.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/worker_task_runner.h"
 #include "content/public/common/platform_notification_data.h"
 #include "third_party/WebKit/public/platform/WebSerializedOrigin.h"
@@ skipping 64 matching lines @@
                  notification_data,
                  delegate));
 }
 
 void NotificationManager::showPersistent(
     const blink::WebSerializedOrigin& origin,
     const blink::WebNotificationData& notification_data,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebNotificationShowCallbacks* callbacks) {
   DCHECK(service_worker_registration);
-  int64 service_worker_registration_id =
+  int64_t service_worker_registration_id =
       static_cast<WebServiceWorkerRegistrationImpl*>(
           service_worker_registration)->registration_id();
 
   scoped_ptr<blink::WebNotificationShowCallbacks> owned_callbacks(callbacks);
 
   // Verify that the author-provided payload size does not exceed our limit.
   // This is an implementation-defined limit to prevent abuse of notification
   // data as a storage mechanism. A UMA histogram records the requested sizes,
   // which enables us to track how much data authors are attempting to store.
   //
@@ skipping 33 matching lines @@
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebNotificationGetCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
 
   WebServiceWorkerRegistrationImpl* service_worker_registration_impl =
       static_cast<WebServiceWorkerRegistrationImpl*>(
           service_worker_registration);
 
   GURL origin = GURL(service_worker_registration_impl->scope()).GetOrigin();
-  int64 service_worker_registration_id =
+  int64_t service_worker_registration_id =
       service_worker_registration_impl->registration_id();
 
   // TODO(peter): GenerateNotificationId is more of a request id. Consider
   // renaming the method in the NotificationDispatcher if this makes sense.
   int request_id =
       notification_dispatcher_->GenerateNotificationId(CurrentWorkerId());
 
   pending_get_notification_requests_.AddWithID(callbacks, request_id);
 
   thread_safe_sender_->Send(
@@ skipping 18 matching lines @@
     return;
   }
 
   // It should not be possible for Blink to call close() on a Notification which
   // does not exist in either the pending or active notification lists.
   NOTREACHED();
 }
 
 void NotificationManager::closePersistent(
     const blink::WebSerializedOrigin& origin,
-    const blink::WebString& persistent_notification_id_string) {
-  // TODO(peter): Blink should store the persistent_notification_id as an
-  // int64_t instead of a string. The id, created by Chromium, is a decimal
-  // number that fits in an int64_t, so convert it until the API updates.
-  base::string16 string_value = persistent_notification_id_string;
-
-  int64_t persistent_notification_id = 0;
-  if (!base::StringToInt64(string_value,
-                           &persistent_notification_id)) {
-    NOTREACHED() << "Unable to close persistent notification; invalid id: "
-                  << string_value;
-    return;
-  }
-
+    int64_t persistent_notification_id) {
   thread_safe_sender_->Send(new PlatformNotificationHostMsg_ClosePersistent(
       GURL(origin.string()),
       persistent_notification_id));
 }
 
 void NotificationManager::notifyDelegateDestroyed(
     blink::WebNotificationDelegate* delegate) {
   if (pending_notifications_.CancelPageNotificationFetches(delegate))
     return;
 
@@ skipping 81 matching lines @@
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   scoped_ptr<blink::WebVector<blink::WebPersistentNotificationInfo>>
       notifications(new blink::WebVector<blink::WebPersistentNotificationInfo>(
           notification_infos.size()));
 
   for (size_t i = 0; i < notification_infos.size(); ++i) {
     blink::WebPersistentNotificationInfo web_notification_info;
-    web_notification_info.persistentNotificationId =
-        blink::WebString::fromUTF8(notification_infos[i].first);
+    web_notification_info.persistentId = notification_infos[i].first;
     web_notification_info.data =
         ToWebNotificationData(notification_infos[i].second);
 
     (*notifications)[i] = web_notification_info;
   }
 
   callbacks->onSuccess(notifications.release());
 
   pending_get_notification_requests_.Remove(request_id);
 }
@@ skipping 11 matching lines @@
       new PlatformNotificationHostMsg_Show(
           notification_id,
           GURL(origin.string()),
           icon,
           ToPlatformNotificationData(notification_data)));
 }
 
 void NotificationManager::DisplayPersistentNotification(
     const blink::WebSerializedOrigin& origin,
     const blink::WebNotificationData& notification_data,
-    int64 service_worker_registration_id,
+    int64_t service_worker_registration_id,
     scoped_ptr<blink::WebNotificationShowCallbacks> callbacks,
     const SkBitmap& icon) {
   // TODO(peter): GenerateNotificationId is more of a request id. Consider
   // renaming the method in the NotificationDispatcher if this makes sense.
   int request_id =
       notification_dispatcher_->GenerateNotificationId(CurrentWorkerId());
 
   pending_show_notification_requests_.AddWithID(callbacks.release(),
                                                 request_id);
 
   thread_safe_sender_->Send(
       new PlatformNotificationHostMsg_ShowPersistent(
           request_id,
           service_worker_registration_id,
           GURL(origin.string()),
           icon,
           ToPlatformNotificationData(notification_data)));
 }
 
 }  // namespace content