Backend changes for notifications content settings.

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 209 matching lines @@
 // 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);
+    allowed_origins = GetAllowedOrigins();
+    denied_origins = GetBlockedOrigins();
   }
 
   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() {
@@ skipping 41 matching lines @@
 }
 
 void DesktopNotificationService::Observe(NotificationType type,
                                          const NotificationSource& source,
                                          const NotificationDetails& details) {
   DCHECK(NotificationType::PREF_CHANGED == type);
   PrefService* prefs = profile_->GetPrefs();
   std::wstring* name = Details<std::wstring>(details).ptr();
 
   if (0 == name->compare(prefs::kDesktopNotificationAllowedOrigins)) {
-    const ListValue* allowed_sites =
-        prefs->GetList(prefs::kDesktopNotificationAllowedOrigins);
-    std::vector<GURL> allowed_origins;
-    if (allowed_sites) {
-      NotificationsPrefsCache::ListValueToGurlVector(*allowed_sites,
-                                                     &allowed_origins);
-    }
+    std::vector<GURL> allowed_origins(GetAllowedOrigins());
     // Schedule a cache update on the IO thread.
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(
             prefs_cache_.get(),
             &NotificationsPrefsCache::SetCacheAllowedOrigins,
             allowed_origins));
   } else if (0 == name->compare(prefs::kDesktopNotificationDeniedOrigins)) {
-    const ListValue* denied_sites =
-        prefs->GetList(prefs::kDesktopNotificationDeniedOrigins);
-    std::vector<GURL> denied_origins;
-    if (denied_sites) {
-      NotificationsPrefsCache::ListValueToGurlVector(*denied_sites,
-                                                     &denied_origins);
-    }
+    std::vector<GURL> denied_origins(GetBlockedOrigins());
     // 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(
@@ skipping 10 matching lines @@
 }
 
 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();
 
+  // |Observe()| updates the whole permission set in the cache, but only a
+  // single origin has changed. Hence, callers of this method manually
+  // schedule a task to update the prefs cache, and the prefs observer is
+  // disabled while the update runs.
   StopObserving();
 
   bool allowed_changed = false;
   bool denied_changed = false;
 
   ListValue* allowed_sites =
       prefs->GetMutableList(prefs::kDesktopNotificationAllowedOrigins);
   ListValue* denied_sites =
       prefs->GetMutableList(prefs::kDesktopNotificationDeniedOrigins);
   {
@@ skipping 21 matching lines @@
         denied_changed = true;
       else
         delete value;
     }
   }
 
   // Persist the pref if anthing changed, but only send updates for the
   // list that changed.
   if (allowed_changed || denied_changed) {
     if (allowed_changed) {
-      ScopedPrefUpdate updateAllowed(
+      ScopedPrefUpdate update_allowed(
           prefs, prefs::kDesktopNotificationAllowedOrigins);
     }
     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);
   // The cache is updated through the notification observer.
 }
 
+std::vector<GURL> DesktopNotificationService::GetAllowedOrigins() {
+  std::vector<GURL> allowed_origins;
+  PrefService* prefs = profile_->GetPrefs();
+  const ListValue* allowed_sites =
+      prefs->GetList(prefs::kDesktopNotificationAllowedOrigins);
+  if (allowed_sites) {
+    NotificationsPrefsCache::ListValueToGurlVector(*allowed_sites,
+                                                   &allowed_origins);
+  }
+  return allowed_origins;
+}
+
+std::vector<GURL> DesktopNotificationService::GetBlockedOrigins() {
+  std::vector<GURL> denied_origins;
+  PrefService* prefs = profile_->GetPrefs();
+  const ListValue* denied_sites =
+      prefs->GetList(prefs::kDesktopNotificationDeniedOrigins);
+  if (denied_sites) {
+    NotificationsPrefsCache::ListValueToGurlVector(*denied_sites,
+                                                   &denied_origins);
+  }
+  return denied_origins;
+}
+
+void DesktopNotificationService::ResetAllowedOrigin(const GURL& origin) {
+  if (profile_->IsOffTheRecord())
+    return;
+
+  // Since this isn't called often, let the normal observer behavior update the
+  // cache in this case.
+  PrefService* prefs = profile_->GetPrefs();
+  ListValue* allowed_sites =
+      prefs->GetMutableList(prefs::kDesktopNotificationAllowedOrigins);
+  {
+    StringValue value(origin.spec());
+    int removed_index = allowed_sites->Remove(value);
+    DCHECK_NE(-1, removed_index) << origin << " was not allowed";
+    ScopedPrefUpdate update_allowed(
+        prefs, prefs::kDesktopNotificationAllowedOrigins);
+  }
+  prefs->ScheduleSavePersistentPrefs();
+}
+
+void DesktopNotificationService::ResetBlockedOrigin(const GURL& origin) {
+  if (profile_->IsOffTheRecord())
+    return;
+
+  // Since this isn't called often, let the normal observer behavior update the
+  // cache in this case.
+  PrefService* prefs = profile_->GetPrefs();
+  ListValue* denied_sites =
+      prefs->GetMutableList(prefs::kDesktopNotificationDeniedOrigins);
+  {
+    StringValue value(origin.spec());
+    int removed_index = denied_sites->Remove(value);
+    DCHECK_NE(-1, removed_index) << origin << " was not blocked";
+    ScopedPrefUpdate update_allowed(
+        prefs, prefs::kDesktopNotificationDeniedOrigins);
+  }
+  prefs->ScheduleSavePersistentPrefs();
+}
+
+void DesktopNotificationService::ResetAllOrigins() {
+  PrefService* prefs = profile_->GetPrefs();
+  prefs->ClearPref(prefs::kDesktopNotificationAllowedOrigins);
+  prefs->ClearPref(prefs::kDesktopNotificationDeniedOrigins);
+}
+
+ContentSetting DesktopNotificationService::GetContentSetting(
+    const GURL& origin) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (profile_->IsOffTheRecord())
+    return kDefaultSetting;
+
+  std::vector<GURL> allowed_origins(GetAllowedOrigins());
+  if (std::find(allowed_origins.begin(), allowed_origins.end(), origin) !=
+      allowed_origins.end())
+    return CONTENT_SETTING_ALLOW;
+
+  std::vector<GURL> denied_origins(GetBlockedOrigins());
+  if (std::find(denied_origins.begin(), denied_origins.end(), origin) !=
+      denied_origins.end())
+    return CONTENT_SETTING_BLOCK;
+
+  return GetDefaultContentSetting();
+}
+
 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());
 }