Support persistent incognito preferences

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 95 matching lines @@
 const char kPrefGrantedPermissionsAPI[] = "granted_permissions.api";
 const char kPrefGrantedPermissionsHost[] = "granted_permissions.host";
 const char kPrefGrantedPermissionsAll[] = "granted_permissions.full";
 
 // A preference that indicates when an extension was installed.
 const char kPrefInstallTime[] = "install_time";
 
 // 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";
 
 // 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),
@@ skipping 17 matching lines @@
  private:
   PrefService* prefs_;
   const std::string extension_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedExtensionPrefUpdate);
 };
 
 // Provider of write access to a dictionary storing extension controlled prefs.
 class ScopedExtensionControlledPrefUpdate : public DictionaryPrefUpdate {
  public:
-  ScopedExtensionControlledPrefUpdate(PrefService* service,
-                                      const std::string& extension_id) :
+  // |incognito_or_regular_path| indicates the sub-path where the
+  // extension controlled preferences are stored. This has to be either
+  // kPrefPreferences or kPrefIncognitoPreferences.
+  ScopedExtensionControlledPrefUpdate(
+      PrefService* service,
+      const std::string& extension_id,
+      const std::string& incognito_or_regular_path) :
     DictionaryPrefUpdate(service, ExtensionPrefs::kExtensionsPref),
     prefs_(service),
-    extension_id_(extension_id) {}
+    extension_id_(extension_id),
+    incognito_or_regular_path_(incognito_or_regular_path) {}
 
   virtual ~ScopedExtensionControlledPrefUpdate() {
     prefs_->ScheduleSavePersistentPrefs();
   }
 
   virtual DictionaryValue* Get() {
     DictionaryValue* dict = DictionaryPrefUpdate::Get();
     DictionaryValue* preferences = NULL;
-    std::string key = extension_id_ + std::string(".") + kPrefPreferences;
+    std::string key =
+        extension_id_ + std::string(".") + incognito_or_regular_path_;
     if (!dict->GetDictionary(key, &preferences)) {
       preferences = new DictionaryValue;
       dict->Set(key, preferences);
     }
     return preferences;
   }
 
  private:
   PrefService* prefs_;
   const std::string extension_id_;
+  const std::string incognito_or_regular_path_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedExtensionControlledPrefUpdate);
 };
 
 // TODO(mihaip): This is cleanup code for keys for unpacked extensions (which
 // are derived from paths). As part of the wstring removal, we changed the way
 // we hash paths, so we need to move prefs from their old synthesized IDs to
 // their new ones. We can remove this by July 2011. (See http://crbug.com/75945
 // for more details).
 static void CleanupBadExtensionKeys(const FilePath& root_dir,
@@ skipping 688 matching lines @@
   ScopedExtensionPrefUpdate update(prefs_, id);
   DictionaryValue* extension_dict = update.Get();
   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());
 
   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 472 matching lines @@
                 << kPrefInstallTime << " was introduced. Updating "
                 << kPrefInstallTime << " to the current time.";
       const base::Time install_time = GetCurrentTime();
       UpdateExtensionPref(*ext_id, kPrefInstallTime, Value::CreateStringValue(
           base::Int64ToString(install_time.ToInternalValue())));
     }
   }
 }
 
 const DictionaryValue* ExtensionPrefs::GetExtensionControlledPrefs(
-    const std::string& extension_id) const {
-  std::string key = extension_id + std::string(".") + kPrefPreferences;
+    const std::string& extension_id,
+    bool incognito) const {
+  std::string key = extension_id + std::string(".") +
+      (incognito ? kPrefIncognitoPreferences : kPrefPreferences);
   DictionaryValue* preferences = NULL;
   // First try the regular lookup.
   const DictionaryValue* source_dict = prefs_->GetDictionary(kExtensionsPref);
   if (!source_dict->GetDictionary(key, &preferences)) {
     // And then create a dictionary if it did not exist before.
     DictionaryPrefUpdate update(prefs_, kExtensionsPref);
     preferences = new DictionaryValue;
     update->Set(key, preferences);
   }
   return preferences;
@@ skipping 21 matching lines @@
        ext_id != extension_ids.end(); ++ext_id) {
     extension_pref_value_map_->RegisterExtension(
         *ext_id,
         GetInstallTime(*ext_id),
         GetExtensionState(*ext_id) == Extension::ENABLED);
     content_settings_store_->RegisterExtension(
         *ext_id,
         GetInstallTime(*ext_id),
         GetExtensionState(*ext_id) == Extension::ENABLED);
 
-    const DictionaryValue* prefs = GetExtensionControlledPrefs(*ext_id);
+    // Set regular extension controlled prefs.
+    const DictionaryValue* prefs = GetExtensionControlledPrefs(*ext_id, false);
     for (DictionaryValue::key_iterator i = prefs->begin_keys();
          i != prefs->end_keys(); ++i) {
       Value* value;
       if (!prefs->GetWithoutPathExpansion(*i, &value))
         continue;
       extension_pref_value_map_->SetExtensionPref(
-          *ext_id, *i, false, value->DeepCopy());
+          *ext_id, *i, extension_prefs_scope::kRegular, value->DeepCopy());
+    }
+
+    // Set incognito extension controlled prefs.
+    prefs = GetExtensionControlledPrefs(*ext_id, true);
+    for (DictionaryValue::key_iterator i = prefs->begin_keys();
+         i != prefs->end_keys(); ++i) {
+      Value* value;
+      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)) {
       content_settings_store_->SetExtensionContentSettingsFromList(
           *ext_id, content_settings);
     }
   }
 
   extension_pref_value_map_->NotifyInitializationCompleted();
 }
 
 
-void ExtensionPrefs::SetExtensionControlledPref(const std::string& extension_id,
-                                                const std::string& pref_key,
-                                                bool incognito,
-                                                Value* value) {
+void ExtensionPrefs::SetExtensionControlledPref(
+    const std::string& extension_id,
+    const std::string& pref_key,
+    extension_prefs_scope::Scope scope,
+    Value* value) {
 #ifndef NDEBUG
   const PrefService::Preference* pref =
       pref_service()->FindPreference(pref_key.c_str());
   DCHECK(pref) << "Extension controlled preference key " << pref_key
                << " not registered.";
   DCHECK_EQ(pref->GetType(), value->GetType())
       << "Extension controlled preference " << pref_key << " has wrong type.";
 #endif
 
-  if (!incognito) {
+  if (scope == extension_prefs_scope::kRegular) {
     // Also store in persisted Preferences file to recover after a
     // browser restart.
-    ScopedExtensionControlledPrefUpdate update(prefs_, extension_id);
+    ScopedExtensionControlledPrefUpdate update(prefs_, extension_id,
+                                               kPrefPreferences);
+    update->SetWithoutPathExpansion(pref_key, value->DeepCopy());
+  } else if (scope == extension_prefs_scope::kIncognitoPersistent) {
+    ScopedExtensionControlledPrefUpdate update(prefs_, extension_id,
+                                               kPrefIncognitoPreferences);
     update->SetWithoutPathExpansion(pref_key, value->DeepCopy());
   }
 
   extension_pref_value_map_->SetExtensionPref(
-      extension_id, pref_key, incognito, value);
+      extension_id, pref_key, scope, value);
 }
 
 void ExtensionPrefs::RemoveExtensionControlledPref(
     const std::string& extension_id,
     const std::string& pref_key,
-    bool incognito) {
+    extension_prefs_scope::Scope scope) {
   DCHECK(pref_service()->FindPreference(pref_key.c_str()))
       << "Extension controlled preference key " << pref_key
       << " not registered.";
 
-  if (!incognito) {
+  if (scope == extension_prefs_scope::kRegular) {
     // Also store in persisted Preferences file to recover after a
     // browser restart.
-    ScopedExtensionControlledPrefUpdate update(prefs_, extension_id);
+    ScopedExtensionControlledPrefUpdate update(prefs_, extension_id,
+                                               kPrefPreferences);
+    update->RemoveWithoutPathExpansion(pref_key, NULL);
+  } else if (scope == extension_prefs_scope::kIncognitoPersistent) {
+    ScopedExtensionControlledPrefUpdate update(prefs_, extension_id,
+                                               kPrefIncognitoPreferences);
     update->RemoveWithoutPathExpansion(pref_key, NULL);
   }
 
   extension_pref_value_map_->RemoveExtensionPref(
-      extension_id, pref_key, incognito);
+      extension_id, pref_key, scope);
 }
 
 bool ExtensionPrefs::CanExtensionControlPref(const std::string& extension_id,
                                              const std::string& pref_key,
                                              bool incognito) {
   DCHECK(pref_service()->FindPreference(pref_key.c_str()))
       << "Extension controlled preference key " << pref_key
       << " not registered.";
 
   return extension_pref_value_map_->CanExtensionControlPref(extension_id,
@@ skipping 33 matching lines @@
   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);
 }