Implement support for notification.vibrate

content/browser/notifications/notification_message_filter.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/browser/notifications/notification_message_filter.h"
 
 #include "base/callback.h"
 #include "content/browser/notifications/page_notification_delegate.h"
 #include "content/browser/notifications/platform_notification_context_impl.h"
 #include "content/common/platform_notification_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/desktop_notification_delegate.h"
 #include "content/public/browser/notification_database_data.h"
 #include "content/public/browser/platform_notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
 
 namespace content {
 
+namespace {
+
+const int kMinimumVibrationDurationMs = 1;  // 1 millisecond
+const int kMaximumVibrationDurationMs = 10000;  // 10 seconds
+
+PlatformNotificationData SanitizeNotificationData(
+    const PlatformNotificationData& notification_data) {
+  PlatformNotificationData sanitized_data;

[dcheng, 2015/05/08 20:22:27]

My point was that you could make use of the copy constructor for
PlatformNotificationData and avoid duplicating all these fields. That also makes
this code more future proof, when you want to add further fields.

[Sanghyun Park, 2015/05/09 15:07:12]

Oops. Sorry, I misunderstand. 
Thank for your detailed explanation.

+
+  sanitized_data.title = notification_data.title;
+  sanitized_data.direction = notification_data.direction;
+  sanitized_data.lang = notification_data.lang;
+  sanitized_data.body = notification_data.body;
+  sanitized_data.tag = notification_data.tag;
+  sanitized_data.icon = notification_data.icon;
+  sanitized_data.vibration_pattern = notification_data.vibration_pattern;
+  sanitized_data.silent = notification_data.silent;
+  sanitized_data.data = notification_data.data;
+
+  // Make sure that the vibration values are within reasonable bounds.
+  for (int& pattern : sanitized_data.vibration_pattern) {
+    pattern = std::min(kMaximumVibrationDurationMs,
+        std::max(kMinimumVibrationDurationMs, pattern));
+  }
+
+  return sanitized_data;
+}
+
+}  // namespace
+
 NotificationMessageFilter::NotificationMessageFilter(
     int process_id,
     PlatformNotificationContextImpl* notification_context,
     ResourceContext* resource_context,
     BrowserContext* browser_context)
     : BrowserMessageFilter(PlatformNotificationMsgStart),
       process_id_(process_id),
       notification_context_(notification_context),
       resource_context_(resource_context),
       browser_context_(browser_context),
@@ skipping 62 matching lines @@
       GetContentClient()->browser()->GetPlatformNotificationService();
   DCHECK(service);
 
   if (!VerifyNotificationPermissionGranted(service, origin))
     return;
 
   base::Closure close_closure;
   service->DisplayNotification(browser_context_,
                                origin,
                                icon,
-                               notification_data,
+                               SanitizeNotificationData(notification_data),
                                delegate.Pass(),
                                &close_closure);
 
   if (!close_closure.is_null())
     close_closures_[notification_id] = close_closure;
 }
 
 void NotificationMessageFilter::OnShowPersistentNotification(
     int request_id,
     int64 service_worker_registration_id,
     const GURL& origin,
     const SkBitmap& icon,
     const PlatformNotificationData& notification_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (GetPermissionForOriginOnIO(origin) !=
           blink::WebNotificationPermissionAllowed) {
     BadMessageReceived();
     return;
   }
 
   NotificationDatabaseData database_data;
   database_data.origin = origin;
   database_data.service_worker_registration_id = service_worker_registration_id;
-  database_data.notification_data = notification_data;
+
+  PlatformNotificationData sanitized_notification_data =
+      SanitizeNotificationData(notification_data);
+  database_data.notification_data = sanitized_notification_data;
 
   // TODO(peter): Significantly reduce the amount of information we need to
   // retain outside of the database for displaying notifications.
   notification_context_->WriteNotificationData(
       origin,
       database_data,
       base::Bind(&NotificationMessageFilter::DidWritePersistentNotificationData,
                  weak_factory_io_.GetWeakPtr(),
                  request_id,
                  origin,
                  icon,
-                 notification_data));
+                 sanitized_notification_data));
 }
 
 void NotificationMessageFilter::DidWritePersistentNotificationData(
     int request_id,
     const GURL& origin,
     const SkBitmap& icon,
     const PlatformNotificationData& notification_data,
     bool success,
     int64_t persistent_notification_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 142 matching lines @@
                                          process_id_);
 
   if (permission == blink::WebNotificationPermissionAllowed)
     return true;
 
   BadMessageReceived();
   return false;
 }
 
 }  // namespace content