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

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 101 matching lines @@
 
 // A preference that contains any extension-controlled preferences.
 const char kPrefPreferences[] = "preferences";
 
 // A preference that contains any extension-controlled incognito preferences.
 const char kPrefIncognitoPreferences[] = "incognito_preferences";
 
 // A preference that contains extension-set content settings.
 const char kPrefContentSettings[] = "content_settings";
 
+// A preference that contains extension-set content settings.
+const char kPrefIncognitoContentSettings[] = "incognito_content_settings";
+
 // Provider of write access to a dictionary storing extension prefs.
 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedExtensionPrefUpdate(PrefService* service,
                             const std::string& extension_id) :
     DictionaryPrefUpdate(service, ExtensionPrefs::kExtensionsPref),
     prefs_(service),
     extension_id_(extension_id) {}
 
   virtual ~ScopedExtensionPrefUpdate() {
@@ skipping 756 matching lines @@
   const base::Time install_time = GetCurrentTime();
   extension_dict->Set(kPrefState, Value::CreateIntegerValue(initial_state));
   extension_dict->Set(kPrefLocation,
                       Value::CreateIntegerValue(extension->location()));
   extension_dict->Set(kPrefInstallTime,
                       Value::CreateStringValue(
                           base::Int64ToString(install_time.ToInternalValue())));
   extension_dict->Set(kPrefPreferences, new DictionaryValue());
   extension_dict->Set(kPrefIncognitoPreferences, new DictionaryValue());
   extension_dict->Set(kPrefContentSettings, new ListValue());
+  extension_dict->Set(kPrefIncognitoContentSettings, new ListValue());
 
   FilePath::StringType path = MakePathRelative(install_directory_,
       extension->path());
   extension_dict->Set(kPrefPath, Value::CreateStringValue(path));
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (extension->location() != Extension::LOAD) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest_value()->DeepCopy());
   }
@@ skipping 417 matching lines @@
 
   std::string data;
   dictionary->GetString(kUpdateUrlData, &data);
   return data;
 }
 
 base::Time ExtensionPrefs::GetCurrentTime() const {
   return base::Time::Now();
 }
 
-void ExtensionPrefs::OnContentSettingChanged(const std::string& extension_id,
-                                             bool incognito) {
-  if (!incognito) {
+void ExtensionPrefs::OnContentSettingChanged(
+    const std::string& extension_id,
+    bool incognito) {
+  if (incognito) {
+    UpdateExtensionPref(
+        extension_id, kPrefIncognitoContentSettings,
+        content_settings_store_->GetSettingsForExtension(
+            extension_id, extension_prefs_scope::kIncognitoPersistent));
+  } else {
     UpdateExtensionPref(
         extension_id, kPrefContentSettings,
-        content_settings_store_->GetSettingsForExtension(extension_id));
+        content_settings_store_->GetSettingsForExtension(
+            extension_id, extension_prefs_scope::kRegular));
   }
 }
 
 base::Time ExtensionPrefs::GetInstallTime(
     const std::string& extension_id) const {
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension) {
     NOTREACHED();
     return base::Time();
   }
@@ skipping 99 matching lines @@
       if (!prefs->GetWithoutPathExpansion(*i, &value))
         continue;
       extension_pref_value_map_->SetExtensionPref(
           *ext_id, *i, extension_prefs_scope::kIncognitoPersistent,
           value->DeepCopy());
     }
 
     const DictionaryValue* extension_prefs = GetExtensionPref(*ext_id);
     DCHECK(extension_prefs);
     ListValue* content_settings = NULL;
-    if (extension_prefs->GetList(kPrefContentSettings, &content_settings)) {
+    if (extension_prefs->GetList(kPrefContentSettings,
+                                 &content_settings)) {
       content_settings_store_->SetExtensionContentSettingsFromList(
-          *ext_id, content_settings);
+          *ext_id, content_settings,
+          extension_prefs_scope::kRegular);
+    }
+    if (extension_prefs->GetList(kPrefIncognitoContentSettings,
+                                 &content_settings)) {
+      content_settings_store_->SetExtensionContentSettingsFromList(
+          *ext_id, content_settings,
+          extension_prefs_scope::kIncognitoPersistent);
     }
   }
 
   extension_pref_value_map_->NotifyInitializationCompleted();
 }
 
 
 void ExtensionPrefs::SetExtensionControlledPref(
     const std::string& extension_id,
     const std::string& pref_key,
@@ skipping 73 matching lines @@
 }
 
 bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) {
   bool has_incognito_pref_value = false;
   extension_pref_value_map_->GetEffectivePrefValue(pref_key,
                                                    true,
                                                    &has_incognito_pref_value);
   return has_incognito_pref_value;
 }
 
+void ExtensionPrefs::ClearIncognitoSessionOnlyContentSettings() {
+  ExtensionIdSet extension_ids;
+  GetExtensions(&extension_ids);
+  for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
+       ext_id != extension_ids.end(); ++ext_id) {
+    content_settings_store_->ClearContentSettingsForExtension(
+        *ext_id,
+        extension_prefs_scope::kIncognitoSessionOnly);
+  }
+}
+
 // static
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(kExtensionToolbar, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize,
                              -1,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate,
                                 PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }