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 = notification_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