Use NotificationResources instead of a bare SkBitmap.

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 <utility>
 
 #include "base/callback.h"
 #include "content/browser/bad_message.h"
@@ skipping 91 matching lines @@
 void NotificationMessageFilter::OnCheckNotificationPermission(
     const GURL& origin, blink::WebNotificationPermission* permission) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   *permission = GetPermissionForOriginOnIO(origin);
 }
 
 void NotificationMessageFilter::OnShowPlatformNotification(
     int notification_id,
     const GURL& origin,
-    const SkBitmap& icon,
-    const PlatformNotificationData& notification_data) {
+    const PlatformNotificationData& notification_data,
+    const NotificationResources& notification_resources) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!RenderProcessHost::FromID(process_id_))
     return;
 
   scoped_ptr<DesktopNotificationDelegate> delegate(
       new PageNotificationDelegate(process_id_, notification_id));
 
   PlatformNotificationService* service =
       GetContentClient()->browser()->GetPlatformNotificationService();
   DCHECK(service);
 
   if (!VerifyNotificationPermissionGranted(service, origin))
     return;
 
   base::Closure close_closure;
-  service->DisplayNotification(browser_context_, origin, icon,
-                               SanitizeNotificationData(notification_data),
-                               std::move(delegate), &close_closure);
+  service->DisplayNotification(
+      browser_context_, origin, SanitizeNotificationData(notification_data),
+      notification_resources, std::move(delegate), &close_closure);
 
   if (!close_closure.is_null())
     close_closures_[notification_id] = close_closure;
 }
 
 void NotificationMessageFilter::OnShowPersistentNotification(
     int request_id,
     int64_t service_worker_registration_id,
     const GURL& origin,
-    const SkBitmap& icon,
-    const PlatformNotificationData& notification_data) {
+    const PlatformNotificationData& notification_data,
+    const NotificationResources& notification_resources) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (GetPermissionForOriginOnIO(origin) !=
       blink::WebNotificationPermissionAllowed) {
     bad_message::ReceivedBadMessage(this, bad_message::NMF_NO_PERMISSION_SHOW);
     return;
   }
 
   NotificationDatabaseData database_data;
   database_data.origin = origin;
   database_data.service_worker_registration_id = service_worker_registration_id;
 
   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,
-                 sanitized_notification_data));
+                 weak_factory_io_.GetWeakPtr(), request_id, origin,
+                 sanitized_notification_data, notification_resources));
 }
 
 void NotificationMessageFilter::DidWritePersistentNotificationData(
     int request_id,
     const GURL& origin,
-    const SkBitmap& icon,
     const PlatformNotificationData& notification_data,
+    const NotificationResources& notification_resources,
     bool success,
     int64_t persistent_notification_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (success) {
     PlatformNotificationService* service =
         GetContentClient()->browser()->GetPlatformNotificationService();
     DCHECK(service);
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&PlatformNotificationService::DisplayPersistentNotification,
                    base::Unretained(service),  // The service is a singleton.
-                   browser_context_, persistent_notification_id, origin, icon,
-                   notification_data));
+                   browser_context_, persistent_notification_id, origin,
+                   notification_data, notification_resources));
   }
 
   Send(new PlatformNotificationMsg_DidShowPersistent(request_id, success));
 }
 
 void NotificationMessageFilter::OnGetNotifications(
     int request_id,
     int64_t service_worker_registration_id,
     const GURL& origin,
     const std::string& filter_tag) {
@@ skipping 107 matching lines @@
       service->CheckPermissionOnUIThread(browser_context_, origin, process_id_);
 
   if (permission == blink::WebNotificationPermissionAllowed)
     return true;
 
   bad_message::ReceivedBadMessage(this, bad_message::NMF_NO_PERMISSION_VERIFY);
   return false;
 }
 
 }  // namespace content