Remove ShowDesktopNotificationHostMsgParams in favor of PlatformNotificationData.

content/shell/browser/layout_test/layout_test_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/shell/browser/layout_test/layout_test_notification_manager.h"
 
 #include "base/guid.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_notification_delegate.h"
 #include "content/public/browser/notification_event_dispatcher.h"
 #include "content/public/common/persistent_notification_status.h"
-#include "content/public/common/show_desktop_notification_params.h"
+#include "content/public/common/platform_notification_data.h"
 
 namespace content {
 namespace {
 
 // The Web Notification layout tests don't care about the lifetime of the
 // Service Worker when a notificationclick event has been dispatched.
 void OnEventDispatchComplete(PersistentNotificationStatus status) {}
 
 }  // namespace
 
@@ skipping 31 matching lines @@
   permission_map_[origin] = permission;
 }
 
 void LayoutTestNotificationManager::ClearPermissions() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   permission_map_.clear();
 }
 
 void LayoutTestNotificationManager::DisplayNotification(
     BrowserContext* browser_context,
-    const ShowDesktopNotificationHostMsgParams& params,
+    const GURL& origin,
+    const SkBitmap& icon,
+    const PlatformNotificationData& notification_data,
     scoped_ptr<DesktopNotificationDelegate> delegate,
     int render_process_id,
     base::Closure* cancel_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::string title = base::UTF16ToUTF8(params.title);
+  std::string title = base::UTF16ToUTF8(notification_data.title);
 
   DCHECK(cancel_callback);
   *cancel_callback = base::Bind(&LayoutTestNotificationManager::Close,
                                 weak_factory_.GetWeakPtr(),
                                 title);
 
-  ReplaceNotificationIfNeeded(params);
+  ReplaceNotificationIfNeeded(notification_data);
 
   page_notifications_[title] = delegate.release();
   page_notifications_[title]->NotificationDisplayed();
 }
 
 void LayoutTestNotificationManager::DisplayPersistentNotification(
     BrowserContext* browser_context,
     int64 service_worker_registration_id,
-    const ShowDesktopNotificationHostMsgParams& params,
+    const GURL& origin,
+    const SkBitmap& icon,
+    const PlatformNotificationData& notification_data,
     int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::string title = base::UTF16ToUTF8(params.title);
+  std::string title = base::UTF16ToUTF8(notification_data.title);
 
-  ReplaceNotificationIfNeeded(params);
+  ReplaceNotificationIfNeeded(notification_data);
 
   PersistentNotification notification;
   notification.browser_context = browser_context;
-  notification.notification_data = params;
+  notification.origin = origin;
+  notification.notification_data = notification_data;
   notification.service_worker_registration_id = service_worker_registration_id;
   notification.persistent_id = base::GenerateGUID();
 
   persistent_notifications_[title] = notification;
 }
 
 void LayoutTestNotificationManager::ClosePersistentNotification(
     BrowserContext* browser_context,
     const std::string& persistent_notification_id) {
   for (const auto& iter : persistent_notifications_) {
@@ skipping 17 matching lines @@
 
   // Then check for persistent notifications with the given title.
   const auto& persistent_iterator = persistent_notifications_.find(title);
   if (persistent_iterator == persistent_notifications_.end())
     return;
 
   const PersistentNotification& notification = persistent_iterator->second;
   content::NotificationEventDispatcher::GetInstance()
       ->DispatchNotificationClickEvent(
           notification.browser_context,
-          notification.notification_data.origin,
+          notification.origin,
           notification.service_worker_registration_id,
           notification.persistent_id,
           notification.notification_data,
           base::Bind(&OnEventDispatchComplete));
 }
 
 void LayoutTestNotificationManager::Close(const std::string& title) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   auto iterator = page_notifications_.find(title);
   if (iterator == page_notifications_.end())
     return;
 
   iterator->second->NotificationClosed(false);
 }
 
 void LayoutTestNotificationManager::ReplaceNotificationIfNeeded(
-    const ShowDesktopNotificationHostMsgParams& params) {
-  if (!params.replace_id.length())
+    const PlatformNotificationData& notification_data) {
+  if (!notification_data.tag.length())
     return;
 
-  std::string replace_id = base::UTF16ToUTF8(params.replace_id);
+  std::string replace_id = base::UTF16ToUTF8(notification_data.tag);
   const auto& replace_iter = replacements_.find(replace_id);
   if (replace_iter != replacements_.end()) {
     const std::string& previous_title = replace_iter->second;
 
     const auto& page_notification_iter =
         page_notifications_.find(previous_title);
     if (page_notification_iter != page_notifications_.end()) {
       DesktopNotificationDelegate* previous_delegate =
           page_notification_iter->second;
 
       previous_delegate->NotificationClosed(false);
 
       page_notifications_.erase(page_notification_iter);
       delete previous_delegate;
     }
 
     const auto& persistent_notification_iter =
         persistent_notifications_.find(previous_title);
     if (persistent_notification_iter != persistent_notifications_.end())
       persistent_notifications_.erase(persistent_notification_iter);
   }
 
-  replacements_[replace_id] = base::UTF16ToUTF8(params.title);
+  replacements_[replace_id] = base::UTF16ToUTF8(notification_data.title);
 }
 
 }  // namespace content