Add a default content setting to the notifications service.

chrome/browser/notifications/desktop_notification_service.cc

 // Copyright (c) 2010 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 "chrome/browser/notifications/desktop_notification_service.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/thread.h"
 #include "base/utf_string_conversions.h"
@@ skipping 19 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/escape.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebNotificationPresenter.h"
 
 using WebKit::WebNotificationPresenter;
 
+const ContentSetting kDefaultSetting = CONTENT_SETTING_ASK;

[dhollowa, 2010/07/03 02:12:01]

Please wrap in anonymous namespace.

[Nico, 2010/07/03 02:18:29]

Not necessary, consts implicitly have internal linkage.

+
 // static
 string16 DesktopNotificationService::CreateDataUrl(
     const GURL& icon_url, const string16& title, const string16& body) {
   int resource;
   string16 line_name;
   string16 line;
   std::vector<std::string> subst;
   if (icon_url.is_valid()) {
     resource = IDR_NOTIFICATION_ICON_HTML;
     subst.push_back(icon_url.spec());
@@ skipping 146 matching lines @@
       ui_manager_(ui_manager) {
   InitPrefs();
   StartObserving();
 }
 
 DesktopNotificationService::~DesktopNotificationService() {
   StopObserving();
 }
 
 void DesktopNotificationService::RegisterUserPrefs(PrefService* user_prefs) {
+  if (!user_prefs->FindPreference(
+      prefs::kDesktopNotificationDefaultContentSetting)) {
+    user_prefs->RegisterIntegerPref(
+        prefs::kDesktopNotificationDefaultContentSetting, kDefaultSetting);
+  }
   if (!user_prefs->FindPreference(prefs::kDesktopNotificationAllowedOrigins))
     user_prefs->RegisterListPref(prefs::kDesktopNotificationAllowedOrigins);
   if (!user_prefs->FindPreference(prefs::kDesktopNotificationDeniedOrigins))
     user_prefs->RegisterListPref(prefs::kDesktopNotificationDeniedOrigins);
 }
 
 // Initialize the cache with the allowed and denied origins, or
 // create the preferences if they don't exist yet.
 void DesktopNotificationService::InitPrefs() {
   PrefService* prefs = profile_->GetPrefs();
   std::vector<GURL> allowed_origins;
   std::vector<GURL> denied_origins;
+  ContentSetting default_content_setting = CONTENT_SETTING_DEFAULT;
 
   if (!profile_->IsOffTheRecord()) {
+    default_content_setting = IntToContentSetting(
+        prefs->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
+
     const ListValue* allowed_sites =
         prefs->GetList(prefs::kDesktopNotificationAllowedOrigins);
     if (allowed_sites)
       NotificationsPrefsCache::ListValueToGurlVector(*allowed_sites,
                                                      &allowed_origins);
 
     const ListValue* denied_sites =
         prefs->GetList(prefs::kDesktopNotificationDeniedOrigins);
     if (denied_sites)
       NotificationsPrefsCache::ListValueToGurlVector(*denied_sites,
                                                      &denied_origins);
   }
 
   prefs_cache_ = new NotificationsPrefsCache();
+  prefs_cache_->SetCacheDefaultContentSetting(default_content_setting);
   prefs_cache_->SetCacheAllowedOrigins(allowed_origins);
   prefs_cache_->SetCacheDeniedOrigins(denied_origins);
   prefs_cache_->set_is_initialized(true);
 }
 
 void DesktopNotificationService::StartObserving() {
   if (!profile_->IsOffTheRecord()) {
     PrefService* prefs = profile_->GetPrefs();
+    prefs->AddPrefObserver(prefs::kDesktopNotificationDefaultContentSetting,
+                           this);
     prefs->AddPrefObserver(prefs::kDesktopNotificationAllowedOrigins, this);
     prefs->AddPrefObserver(prefs::kDesktopNotificationDeniedOrigins, this);
   }
 }
 
 void DesktopNotificationService::StopObserving() {
   if (!profile_->IsOffTheRecord()) {
     PrefService* prefs = profile_->GetPrefs();
+    prefs->RemovePrefObserver(prefs::kDesktopNotificationDefaultContentSetting,
+                              this);
     prefs->RemovePrefObserver(prefs::kDesktopNotificationAllowedOrigins, this);
     prefs->RemovePrefObserver(prefs::kDesktopNotificationDeniedOrigins, this);
   }
 }
 
 void DesktopNotificationService::GrantPermission(const GURL& origin) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   PersistPermissionChange(origin, true);
 
   // Schedule a cache update on the IO thread.
@@ skipping 46 matching lines @@
       NotificationsPrefsCache::ListValueToGurlVector(*denied_sites,
                                                      &denied_origins);
     }
     // Schedule a cache update on the IO thread.
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(
             prefs_cache_.get(),
             &NotificationsPrefsCache::SetCacheDeniedOrigins,
             denied_origins));
+  } else if (0 == name->compare(
+      prefs::kDesktopNotificationDefaultContentSetting)) {
+    const ContentSetting default_content_setting = IntToContentSetting(
+        prefs->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
+
+    // Schedule a cache update on the IO thread.
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(
+            prefs_cache_.get(),
+            &NotificationsPrefsCache::SetCacheDefaultContentSetting,
+            default_content_setting));
   }
 }
 
 void DesktopNotificationService::PersistPermissionChange(
     const GURL& origin, bool is_allowed) {
   // Don't persist changes when off the record.
   if (profile_->IsOffTheRecord())
     return;
 
   PrefService* prefs = profile_->GetPrefs();
@@ skipping 44 matching lines @@
     }
     if (denied_changed) {
       ScopedPrefUpdate updateDenied(
           prefs, prefs::kDesktopNotificationDeniedOrigins);
     }
     prefs->ScheduleSavePersistentPrefs();
   }
   StartObserving();
 }
 
+ContentSetting DesktopNotificationService::GetDefaultContentSetting() {
+  PrefService* prefs = profile_->GetPrefs();
+  ContentSetting setting = IntToContentSetting(
+      prefs->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
+  if (setting == CONTENT_SETTING_DEFAULT)
+    setting = kDefaultSetting;
+  return setting;
+}
+
+void DesktopNotificationService::SetDefaultContentSetting(
+    ContentSetting setting) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  profile_->GetPrefs()->SetInteger(
+      prefs::kDesktopNotificationDefaultContentSetting,
+      setting == CONTENT_SETTING_DEFAULT ?  kDefaultSetting : setting);

[dhollowa, 2010/07/03 02:12:01]

There's an asymmetry here with respect to |GetDefaultContentSetting|.  You read
CONTENT_SETTING_DEFAULT but you never write CONTENT_SETTING_DEFAULT.  Is this
intended?

[Nico, 2010/07/03 02:18:29]

Yes, CONTENT_SETTING_DEFAULT should never be stored on disk.

[Nico, 2010/07/03 02:33:18]

(This mirrors SetDefaultContentSetting() and ReadDefaultSettings() in
c/b/host_content_settings_map.cc)

+  // The cache is updated through the notification observer.
+}
+
 void DesktopNotificationService::RequestPermission(
     const GURL& origin, int process_id, int route_id, int callback_context,
     TabContents* tab) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   if (!tab)
     return;
   // Show an info bar requesting permission.
   std::wstring display_name = DisplayNameForOrigin(origin);
 
   tab->AddInfoBar(new NotificationPermissionInfoBarDelegate(
@@ skipping 51 matching lines @@
   if (origin.SchemeIs(chrome::kExtensionScheme)) {
     ExtensionsService* ext_service = profile_->GetExtensionsService();
     if (ext_service) {
       Extension* extension = ext_service->GetExtensionByURL(origin);
       if (extension)
         return UTF8ToWide(extension->name());
     }
   }
   return UTF8ToWide(origin.host());
 }