content/shell/browser/layout_test/layout_test_notification_manager.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/shell/browser/layout_test/layout_test_notification_manager.h"
   6
   7 #include "base/guid.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "content/public/browser/browser_thread.h"
  10 #include "content/public/browser/desktop_notification_delegate.h"
  11 #include "content/public/browser/notification_event_dispatcher.h"
  12 #include "content/public/browser/permission_type.h"
  13 #include "content/public/common/persistent_notification_status.h"
  14 #include "content/public/common/platform_notification_data.h"
  15 #include "content/shell/browser/layout_test/layout_test_browser_context.h"
  16 #include "content/shell/browser/layout_test/layout_test_content_browser_client.h"
  17 #include "content/shell/browser/layout_test/layout_test_permission_manager.h"
  18
  19 namespace content {
  20 namespace {
  21
  22 // The Web Notification layout tests don't care about the lifetime of the
  23 // Service Worker when a notificationclick event has been dispatched.
  24 void OnEventDispatchComplete(PersistentNotificationStatus status) {}
  25
  26 blink::WebNotificationPermission ToWebNotificationPermission(
  27     PermissionStatus status) {
  28   switch (status) {
  29     case PERMISSION_STATUS_GRANTED:
  30       return blink::WebNotificationPermissionAllowed;
  31     case PERMISSION_STATUS_DENIED:
  32       return blink::WebNotificationPermissionDenied;
  33     case PERMISSION_STATUS_ASK:
  34       return blink::WebNotificationPermissionDefault;
  35   }
  36
  37   NOTREACHED();
  38   return blink::WebNotificationPermissionLast;
  39 }
  40
  41 }  // namespace
  42
  43 LayoutTestNotificationManager::LayoutTestNotificationManager()
  44     : weak_factory_(this) {}
  45
  46 LayoutTestNotificationManager::~LayoutTestNotificationManager() {}
  47
  48 void LayoutTestNotificationManager::DisplayNotification(
  49     BrowserContext* browser_context,
  50     const GURL& origin,
  51     const SkBitmap& icon,
  52     const PlatformNotificationData& notification_data,
  53     scoped_ptr<DesktopNotificationDelegate> delegate,
  54     base::Closure* cancel_callback) {
  55   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  56   std::string title = base::UTF16ToUTF8(notification_data.title);
  57
  58   DCHECK(cancel_callback);
  59   *cancel_callback = base::Bind(&LayoutTestNotificationManager::Close,
  60                                 weak_factory_.GetWeakPtr(),
  61                                 title);
  62
  63   ReplaceNotificationIfNeeded(notification_data);
  64
  65   page_notifications_[title] = delegate.release();
  66   page_notifications_[title]->NotificationDisplayed();
  67 }
  68
  69 void LayoutTestNotificationManager::DisplayPersistentNotification(
  70     BrowserContext* browser_context,
  71     int64_t persistent_notification_id,
  72     const GURL& origin,
  73     const SkBitmap& icon,
  74     const PlatformNotificationData& notification_data) {
  75   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  76   std::string title = base::UTF16ToUTF8(notification_data.title);
  77
  78   ReplaceNotificationIfNeeded(notification_data);
  79
  80   PersistentNotification notification;
  81   notification.browser_context = browser_context;
  82   notification.origin = origin;
  83   notification.persistent_id = persistent_notification_id;
  84
  85   persistent_notifications_[title] = notification;
  86 }
  87
  88 void LayoutTestNotificationManager::ClosePersistentNotification(
  89     BrowserContext* browser_context,
  90     int64_t persistent_notification_id) {
  91   for (const auto& iter : persistent_notifications_) {
  92     if (iter.second.persistent_id != persistent_notification_id)
  93       continue;
  94
  95     persistent_notifications_.erase(iter.first);
  96     return;
  97   }
  98 }
  99
 100 bool LayoutTestNotificationManager::GetDisplayedPersistentNotifications(
 101     BrowserContext* browser_context,
 102     std::set<std::string>* displayed_notifications) {
 103   DCHECK(displayed_notifications);
 104
 105   // Notifications will never outlive the lifetime of running layout tests.
 106   return false;
 107 }
 108
 109 void LayoutTestNotificationManager::SimulateClick(const std::string& title) {
 110   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 111
 112   // First check for page-notifications with the given title.
 113   const auto& page_iterator = page_notifications_.find(title);
 114   if (page_iterator != page_notifications_.end()) {
 115     page_iterator->second->NotificationClick();
 116     return;
 117   }
 118
 119   // Then check for persistent notifications with the given title.
 120   const auto& persistent_iterator = persistent_notifications_.find(title);
 121   if (persistent_iterator == persistent_notifications_.end())
 122     return;
 123
 124   const PersistentNotification& notification = persistent_iterator->second;
 125   content::NotificationEventDispatcher::GetInstance()
 126       ->DispatchNotificationClickEvent(
 127           notification.browser_context,
 128           notification.persistent_id,
 129           notification.origin,
 130           base::Bind(&OnEventDispatchComplete));
 131 }
 132
 133 blink::WebNotificationPermission
 134 LayoutTestNotificationManager::CheckPermissionOnUIThread(
 135     BrowserContext* browser_context,
 136     const GURL& origin,
 137     int render_process_id) {
 138   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 139   return CheckPermission(origin);
 140 }
 141
 142 blink::WebNotificationPermission
 143 LayoutTestNotificationManager::CheckPermissionOnIOThread(
 144     ResourceContext* resource_context,
 145     const GURL& origin,
 146     int render_process_id) {
 147   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 148   return CheckPermission(origin);
 149 }
 150
 151 void LayoutTestNotificationManager::Close(const std::string& title) {
 152   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 153   auto iterator = page_notifications_.find(title);
 154   if (iterator == page_notifications_.end())
 155     return;
 156
 157   iterator->second->NotificationClosed();
 158 }
 159
 160 void LayoutTestNotificationManager::ReplaceNotificationIfNeeded(
 161     const PlatformNotificationData& notification_data) {
 162   if (!notification_data.tag.length())
 163     return;
 164
 165   std::string tag = notification_data.tag;
 166   const auto& replace_iter = replacements_.find(tag);
 167   if (replace_iter != replacements_.end()) {
 168     const std::string& previous_title = replace_iter->second;
 169
 170     const auto& page_notification_iter =
 171         page_notifications_.find(previous_title);
 172     if (page_notification_iter != page_notifications_.end()) {
 173       DesktopNotificationDelegate* previous_delegate =
 174           page_notification_iter->second;
 175
 176       previous_delegate->NotificationClosed();
 177
 178       page_notifications_.erase(page_notification_iter);
 179       delete previous_delegate;
 180     }
 181
 182     const auto& persistent_notification_iter =
 183         persistent_notifications_.find(previous_title);
 184     if (persistent_notification_iter != persistent_notifications_.end())
 185       persistent_notifications_.erase(persistent_notification_iter);
 186   }
 187
 188   replacements_[tag] = base::UTF16ToUTF8(notification_data.title);
 189 }
 190
 191 blink::WebNotificationPermission
 192 LayoutTestNotificationManager::CheckPermission(const GURL& origin) {
 193   return ToWebNotificationPermission(LayoutTestContentBrowserClient::Get()
 194       ->GetLayoutTestBrowserContext()
 195       ->GetLayoutTestPermissionManager()
 196       ->GetPermissionStatus(PermissionType::NOTIFICATIONS,
 197                             origin,
 198                             origin));
 199 }
 200
 201 }  // namespace content