src/chrome/browser/notifications/desktop_notification_service.cc

   1 // Copyright (c) 2012 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 "chrome/browser/notifications/desktop_notification_service.h"
   6
   7 #include "base/bind.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/prefs/scoped_user_pref_update.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/threading/thread.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
  15 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
  16 #include "chrome/browser/notifications/notification.h"
  17 #include "chrome/browser/notifications/notification_object_proxy.h"
  18 #include "chrome/browser/notifications/notification_ui_manager.h"
  19 #include "chrome/browser/notifications/sync_notifier/chrome_notifier_service.h"
  20 #include "chrome/browser/notifications/sync_notifier/chrome_notifier_service_factory.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/ui/browser.h"
  23 #include "chrome/common/pref_names.h"
  24 #include "chrome/common/url_constants.h"
  25 #include "components/pref_registry/pref_registry_syncable.h"
  26 #include "content/public/browser/browser_thread.h"
  27 #include "content/public/browser/desktop_notification_delegate.h"
  28 #include "content/public/browser/notification_service.h"
  29 #include "content/public/browser/render_frame_host.h"
  30 #include "content/public/browser/render_process_host.h"
  31 #include "content/public/browser/render_view_host.h"
  32 #include "content/public/browser/web_contents.h"
  33 #include "content/public/common/show_desktop_notification_params.h"
  34 #include "ui/base/webui/web_ui_util.h"
  35 #include "ui/message_center/notifier_settings.h"
  36
  37 #if defined(ENABLE_EXTENSIONS)
  38 #include "chrome/browser/extensions/api/notifications/notifications_api.h"
  39 #include "chrome/browser/extensions/extension_service.h"
  40 #include "extensions/browser/event_router.h"
  41 #include "extensions/browser/extension_registry.h"
  42 #include "extensions/browser/extension_system.h"
  43 #include "extensions/browser/extension_util.h"
  44 #include "extensions/browser/info_map.h"
  45 #include "extensions/common/constants.h"
  46 #include "extensions/common/extension.h"
  47 #include "extensions/common/extension_set.h"
  48 #endif
  49
  50 using blink::WebTextDirection;
  51 using content::BrowserThread;
  52 using content::RenderViewHost;
  53 using content::WebContents;
  54 using message_center::NotifierId;
  55
  56 namespace {
  57
  58 void CancelNotification(const std::string& id) {
  59   g_browser_process->notification_ui_manager()->CancelById(id);
  60 }
  61
  62 }  // namespace
  63
  64 // DesktopNotificationService -------------------------------------------------
  65
  66 // static
  67 void DesktopNotificationService::RegisterProfilePrefs(
  68     user_prefs::PrefRegistrySyncable* registry) {
  69   registry->RegisterListPref(
  70       prefs::kMessageCenterDisabledExtensionIds,
  71       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
  72   registry->RegisterListPref(
  73       prefs::kMessageCenterDisabledSystemComponentIds,
  74       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
  75 }
  76
  77 // static
  78 std::string DesktopNotificationService::AddIconNotification(
  79     const GURL& origin_url,
  80     const base::string16& title,
  81     const base::string16& message,
  82     const gfx::Image& icon,
  83     const base::string16& replace_id,
  84     NotificationDelegate* delegate,
  85     Profile* profile) {
  86   Notification notification(message_center::NOTIFICATION_TYPE_SIMPLE,
  87                             origin_url,
  88                             title,
  89                             message,
  90                             icon,
  91                             blink::WebTextDirectionDefault,
  92                             message_center::NotifierId(origin_url),
  93                             base::string16(),
  94                             replace_id,
  95                             message_center::RichNotificationData(),
  96                             delegate);
  97   g_browser_process->notification_ui_manager()->Add(notification, profile);
  98   return notification.delegate_id();
  99 }
 100
 101 DesktopNotificationService::DesktopNotificationService(Profile* profile)
 102     : PermissionContextBase(profile, CONTENT_SETTINGS_TYPE_NOTIFICATIONS),
 103       profile_(profile),
 104 #if defined(ENABLE_EXTENSIONS)
 105       extension_registry_observer_(this),
 106 #endif
 107       weak_factory_(this) {
 108   OnStringListPrefChanged(
 109       prefs::kMessageCenterDisabledExtensionIds, &disabled_extension_ids_);
 110   OnStringListPrefChanged(
 111       prefs::kMessageCenterDisabledSystemComponentIds,
 112       &disabled_system_component_ids_);
 113   disabled_extension_id_pref_.Init(
 114       prefs::kMessageCenterDisabledExtensionIds,
 115       profile_->GetPrefs(),
 116       base::Bind(
 117           &DesktopNotificationService::OnStringListPrefChanged,
 118           base::Unretained(this),
 119           base::Unretained(prefs::kMessageCenterDisabledExtensionIds),
 120           base::Unretained(&disabled_extension_ids_)));
 121   disabled_system_component_id_pref_.Init(
 122       prefs::kMessageCenterDisabledSystemComponentIds,
 123       profile_->GetPrefs(),
 124       base::Bind(
 125           &DesktopNotificationService::OnStringListPrefChanged,
 126           base::Unretained(this),
 127           base::Unretained(prefs::kMessageCenterDisabledSystemComponentIds),
 128           base::Unretained(&disabled_system_component_ids_)));
 129 #if defined(ENABLE_EXTENSIONS)
 130   extension_registry_observer_.Add(
 131       extensions::ExtensionRegistry::Get(profile_));
 132 #endif
 133 }
 134
 135 DesktopNotificationService::~DesktopNotificationService() {
 136 }
 137
 138 void DesktopNotificationService::RequestNotificationPermission(
 139     content::WebContents* web_contents,
 140     const PermissionRequestID& request_id,
 141     const GURL& requesting_frame,
 142     bool user_gesture,
 143     const NotificationPermissionCallback& callback) {
 144   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 145   RequestPermission(
 146       web_contents,
 147       request_id,
 148       requesting_frame,
 149       user_gesture,
 150       base::Bind(&DesktopNotificationService::OnNotificationPermissionRequested,
 151                  weak_factory_.GetWeakPtr(),
 152                  callback));
 153 }
 154
 155 void DesktopNotificationService::ShowDesktopNotification(
 156     const content::ShowDesktopNotificationHostMsgParams& params,
 157     content::RenderFrameHost* render_frame_host,
 158     scoped_ptr<content::DesktopNotificationDelegate> delegate,
 159     base::Closure* cancel_callback) {
 160   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 161   const GURL& origin = params.origin;
 162   NotificationObjectProxy* proxy =
 163       new NotificationObjectProxy(render_frame_host, delegate.Pass());
 164
 165   base::string16 display_source = DisplayNameForOriginInProcessId(
 166       origin, render_frame_host->GetProcess()->GetID());
 167   Notification notification(origin, params.icon_url, params.title,
 168       params.body, params.direction, display_source, params.replace_id,
 169       proxy);
 170
 171   // The webkit notification doesn't timeout.
 172   notification.set_never_timeout(true);
 173
 174   g_browser_process->notification_ui_manager()->Add(notification, profile_);
 175   if (cancel_callback)
 176     *cancel_callback = base::Bind(&CancelNotification, proxy->id());
 177
 178   DesktopNotificationProfileUtil::UsePermission(profile_, origin);
 179 }
 180
 181 base::string16 DesktopNotificationService::DisplayNameForOriginInProcessId(
 182     const GURL& origin, int process_id) {
 183 #if defined(ENABLE_EXTENSIONS)
 184   // If the source is an extension, lookup the display name.
 185   if (origin.SchemeIs(extensions::kExtensionScheme)) {
 186     extensions::InfoMap* extension_info_map =
 187         extensions::ExtensionSystem::Get(profile_)->info_map();
 188     if (extension_info_map) {
 189       extensions::ExtensionSet extensions;
 190       extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
 191           origin,
 192           process_id,
 193           extensions::APIPermission::kNotifications,
 194           &extensions);
 195       for (extensions::ExtensionSet::const_iterator iter = extensions.begin();
 196            iter != extensions.end(); ++iter) {
 197         NotifierId notifier_id(NotifierId::APPLICATION, (*iter)->id());
 198         if (IsNotifierEnabled(notifier_id))
 199           return base::UTF8ToUTF16((*iter)->name());
 200       }
 201     }
 202   }
 203 #endif
 204
 205   return base::UTF8ToUTF16(origin.host());
 206 }
 207
 208 bool DesktopNotificationService::IsNotifierEnabled(
 209     const NotifierId& notifier_id) {
 210   switch (notifier_id.type) {
 211     case NotifierId::APPLICATION:
 212       return disabled_extension_ids_.find(notifier_id.id) ==
 213           disabled_extension_ids_.end();
 214     case NotifierId::WEB_PAGE:
 215       return DesktopNotificationProfileUtil::GetContentSetting(
 216           profile_, notifier_id.url) == CONTENT_SETTING_ALLOW;
 217     case NotifierId::SYSTEM_COMPONENT:
 218 #if defined(OS_CHROMEOS)
 219       return disabled_system_component_ids_.find(notifier_id.id) ==
 220           disabled_system_component_ids_.end();
 221 #else
 222       // We do not disable system component notifications.
 223       return true;
 224 #endif
 225   }
 226
 227   NOTREACHED();
 228   return false;
 229 }
 230
 231 void DesktopNotificationService::SetNotifierEnabled(
 232     const NotifierId& notifier_id,
 233     bool enabled) {
 234   DCHECK_NE(NotifierId::WEB_PAGE, notifier_id.type);
 235
 236   bool add_new_item = false;
 237   const char* pref_name = NULL;
 238   scoped_ptr<base::StringValue> id;
 239   switch (notifier_id.type) {
 240     case NotifierId::APPLICATION:
 241       pref_name = prefs::kMessageCenterDisabledExtensionIds;
 242       add_new_item = !enabled;
 243       id.reset(new base::StringValue(notifier_id.id));
 244       FirePermissionLevelChangedEvent(notifier_id, enabled);
 245       break;
 246     case NotifierId::SYSTEM_COMPONENT:
 247 #if defined(OS_CHROMEOS)
 248       pref_name = prefs::kMessageCenterDisabledSystemComponentIds;
 249       add_new_item = !enabled;
 250       id.reset(new base::StringValue(notifier_id.id));
 251 #else
 252       return;
 253 #endif
 254       break;
 255     default:
 256       NOTREACHED();
 257   }
 258   DCHECK(pref_name != NULL);
 259
 260   ListPrefUpdate update(profile_->GetPrefs(), pref_name);
 261   base::ListValue* const list = update.Get();
 262   if (add_new_item) {
 263     // AppendIfNotPresent will delete |adding_value| when the same value
 264     // already exists.
 265     list->AppendIfNotPresent(id.release());
 266   } else {
 267     list->Remove(*id, NULL);
 268   }
 269 }
 270
 271 void DesktopNotificationService::OnStringListPrefChanged(
 272     const char* pref_name, std::set<std::string>* ids_field) {
 273   ids_field->clear();
 274   // Separate GetPrefs()->GetList() to analyze the crash. See crbug.com/322320
 275   const PrefService* pref_service = profile_->GetPrefs();
 276   CHECK(pref_service);
 277   const base::ListValue* pref_list = pref_service->GetList(pref_name);
 278   for (size_t i = 0; i < pref_list->GetSize(); ++i) {
 279     std::string element;
 280     if (pref_list->GetString(i, &element) && !element.empty())
 281       ids_field->insert(element);
 282     else
 283       LOG(WARNING) << i << "-th element is not a string for " << pref_name;
 284   }
 285 }
 286
 287 #if defined(ENABLE_EXTENSIONS)
 288 void DesktopNotificationService::OnExtensionUninstalled(
 289     content::BrowserContext* browser_context,
 290     const extensions::Extension* extension,
 291     extensions::UninstallReason reason) {
 292   NotifierId notifier_id(NotifierId::APPLICATION, extension->id());
 293   if (IsNotifierEnabled(notifier_id))
 294     return;
 295
 296   // The settings for ephemeral apps will be persisted across cache evictions.
 297   if (extensions::util::IsEphemeralApp(extension->id(), profile_))
 298     return;
 299
 300   SetNotifierEnabled(notifier_id, true);
 301 }
 302 #endif
 303
 304 // Unlike other permission types, granting a notification for a given origin
 305 // will not take into account the |embedder_origin|, it will only be based
 306 // on the requesting iframe origin.
 307 // TODO(mukai) Consider why notifications behave differently than
 308 // other permissions. crbug.com/416894
 309 void DesktopNotificationService::UpdateContentSetting(
 310     const GURL& requesting_origin,
 311     const GURL& embedder_origin,
 312     bool allowed) {
 313   if (allowed) {
 314     DesktopNotificationProfileUtil::GrantPermission(
 315         profile_, requesting_origin);
 316   } else {
 317     DesktopNotificationProfileUtil::DenyPermission(profile_, requesting_origin);
 318   }
 319 }
 320
 321 void DesktopNotificationService::OnNotificationPermissionRequested(
 322     const NotificationPermissionCallback& callback, bool allowed) {
 323   blink::WebNotificationPermission permission = allowed ?
 324       blink::WebNotificationPermissionAllowed :
 325       blink::WebNotificationPermissionDenied;
 326
 327   callback.Run(permission);
 328 }
 329
 330 void DesktopNotificationService::FirePermissionLevelChangedEvent(
 331     const NotifierId& notifier_id, bool enabled) {
 332 #if defined(ENABLE_EXTENSIONS)
 333   DCHECK_EQ(NotifierId::APPLICATION, notifier_id.type);
 334   extensions::api::notifications::PermissionLevel permission =
 335       enabled ? extensions::api::notifications::PERMISSION_LEVEL_GRANTED
 336               : extensions::api::notifications::PERMISSION_LEVEL_DENIED;
 337   scoped_ptr<base::ListValue> args(new base::ListValue());
 338   args->Append(new base::StringValue(
 339       extensions::api::notifications::ToString(permission)));
 340   scoped_ptr<extensions::Event> event(new extensions::Event(
 341       extensions::api::notifications::OnPermissionLevelChanged::kEventName,
 342       args.Pass()));
 343   extensions::EventRouter::Get(profile_)
 344       ->DispatchEventToExtension(notifier_id.id, event.Pass());
 345
 346   // Tell the IO thread that this extension's permission for notifications
 347   // has changed.
 348   extensions::InfoMap* extension_info_map =
 349       extensions::ExtensionSystem::Get(profile_)->info_map();
 350   BrowserThread::PostTask(
 351       BrowserThread::IO, FROM_HERE,
 352       base::Bind(&extensions::InfoMap::SetNotificationsDisabled,
 353                  extension_info_map, notifier_id.id, !enabled));
 354 #endif
 355 }