Split incognito extension content settings in session-only and persistent.

chrome/browser/content_settings/content_settings_pref_provider.cc

 // Copyright (c) 2011 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/content_settings/content_settings_pref_provider.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 115 matching lines @@
     ContentSettingsType content_type) const {
   base::AutoLock lock(lock_);
   return default_content_settings_.settings[content_type];
 }
 
 void PrefDefaultProvider::UpdateDefaultSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
-  DCHECK(content_type != CONTENT_SETTINGS_TYPE_PLUGINS ||
-         setting != CONTENT_SETTING_ASK ||
-         CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kEnableClickToPlay));
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
   if (is_incognito_)
     return;
 
   PrefService* prefs = profile_->GetPrefs();
 
   std::string dictionary_path(kTypeNames[content_type]);
   updating_preferences_ = true;
   {
     base::AutoLock lock(lock_);
     DictionaryPrefUpdate update(prefs, prefs::kDefaultContentSettings);
     DictionaryValue* default_settings_dictionary = update.Get();
     if ((setting == CONTENT_SETTING_DEFAULT) ||
         (setting == kDefaultSettings[content_type])) {
       default_content_settings_.settings[content_type] =
           kDefaultSettings[content_type];
       default_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                               NULL);
     } else {
       default_content_settings_.settings[content_type] = setting;
       default_settings_dictionary->SetWithoutPathExpansion(
           dictionary_path, Value::CreateIntegerValue(setting));
     }
   }
   updating_preferences_ = false;
 
-  NotifyObservers(
-      ContentSettingsDetails(ContentSettingsPattern(), content_type, ""));
+  ContentSettingsDetails details(
+      ContentSettingsPattern(), content_type, std::string());
+  NotifyObservers(details);
 }
 
 bool PrefDefaultProvider::DefaultSettingIsManaged(
     ContentSettingsType content_type) const {
   return false;
 }
 
 void PrefDefaultProvider::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
@@ skipping 20 matching lines @@
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kDefaultContentSettings) {
       ReadDefaultSettings(true);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     if (!is_incognito_) {
-      NotifyObservers(ContentSettingsDetails(
-            ContentSettingsPattern(), CONTENT_SETTINGS_TYPE_DEFAULT, ""));
+      ContentSettingsDetails details(ContentSettingsPattern(),
+                                     CONTENT_SETTINGS_TYPE_DEFAULT,
+                                     std::string());
+      NotifyObservers(details);
     }
   } else if (type == NotificationType::PROFILE_DESTROYED) {
     DCHECK_EQ(profile_, Source<Profile>(source).ptr());
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 void PrefDefaultProvider::UnregisterObservers() {
@@ skipping 268 matching lines @@
                                                                NULL);
         } else {
           host_settings_dictionary->SetWithoutPathExpansion(
               dictionary_path, Value::CreateIntegerValue(setting));
         }
       }
     }
   }  // End scope of update.
   updating_preferences_ = false;
 
-  NotifyObservers(ContentSettingsDetails(requesting_pattern, content_type, ""));
+  ContentSettingsDetails details(
+      requesting_pattern, content_type, std::string());
+  NotifyObservers(details);
 }
 
 void PrefProvider::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
     base::AutoLock auto_lock(lock());
     host_content_settings()->clear();
     incognito_settings()->clear();
   }
@@ skipping 50 matching lines @@
             ++i;
           }
         } else {
           ++i;
         }
       }
     }
   }  // End scope of update.
   updating_preferences_ = false;
 
-  NotifyObservers(
-      ContentSettingsDetails(ContentSettingsPattern(), content_type, ""));
+  ContentSettingsDetails details(
+      ContentSettingsPattern(), content_type, std::string());
+  NotifyObservers(details);
 }
 
 void PrefProvider::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == NotificationType::PREF_CHANGED) {
     DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kContentSettingsPatterns) {
       ReadExceptions(true);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     if (!is_incognito()) {
-      NotifyObservers(ContentSettingsDetails(ContentSettingsPattern(),
-                                             CONTENT_SETTINGS_TYPE_DEFAULT,
-                                             ""));
+      ContentSettingsDetails details(ContentSettingsPattern(),
+                                     CONTENT_SETTINGS_TYPE_DEFAULT,
+                                     std::string());
+      NotifyObservers(details);
     }
   } else if (type == NotificationType::PROFILE_DESTROYED) {
     DCHECK_EQ(profile_, Source<Profile>(source).ptr());
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 PrefProvider::~PrefProvider() {
@@ skipping 225 matching lines @@
                         ContentSettingsPattern::FromString(host),
                         CONTENT_SETTINGS_TYPE_POPUPS,
                         "",
                         CONTENT_SETTING_ALLOW);
     }
     prefs->ClearPref(prefs::kPopupWhitelistedHosts);
   }
 }
 
 }  // namespace content_settings