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 {
+
+const int kMinimumVibrationDurationMs = 1;  // 1 millisecond
+const int kMaximumVibrationDurationMs = 10000;  // 10 seconds
+
+content::PlatformNotificationData sanitizeNotificationData(

[dcheng, 2015/05/06 18:43:27]

SanitizeNotificationData, to follow Chrome/Google style.

[Sanghyun Park, 2015/05/07 12:08:33]

Oops, It's my mistake.
I'll change.

+    const content::PlatformNotificationData& notification_data) {
+  content::PlatformNotificationData sanitized_data;
+
+  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;
+
+  // Make sure that the vibration values are within reasonable bounds.
+  std::vector<int> vibration_pattern;
+  for (int pattern_entry : notification_data.vibration_pattern) {
+    pattern_entry = std::min(kMaximumVibrationDurationMs,
+        std::max(kMinimumVibrationDurationMs, pattern_entry));
+
+    vibration_pattern.push_back(pattern_entry);
+  }
+  sanitized_data.vibration_pattern = vibration_pattern;
+
+  sanitized_data.silent = notification_data.silent;
+  sanitized_data.data = notification_data.data;
+
+  return sanitized_data;
+}
+
+}

[dcheng, 2015/05/06 18:43:27]

Convention is to annotate the closing brace with // namespace.

[Sanghyun Park, 2015/05/07 12:08:33]

Done.

+
 namespace content {
 
 NotificationMessageFilter::NotificationMessageFilter(
     int process_id,
     PlatformNotificationContextImpl* notification_context,
     ResourceContext* resource_context,
     BrowserContext* browser_context)
     : BrowserMessageFilter(PlatformNotificationMsgStart),
       process_id_(process_id),
       notification_context_(notification_context),
@@ skipping 64 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