Introduce incognito preference settings.

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/string_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 123 matching lines @@
                               std::set<std::string>* result) {
   ExtensionExtent::PatternList patterns = host_extent.patterns();
   ExtensionExtent::PatternList::const_iterator i;
 
   for (i = patterns.begin(); i != patterns.end(); ++i)
     result->insert(i->GetAsString());
 }
 
 }  // namespace
 
-ExtensionPrefs::ExtensionPrefs(PrefService* prefs,
-                               const FilePath& root_dir,
-                               ExtensionPrefStore* pref_store)
+ExtensionPrefs::ExtensionPrefs(
+    PrefService* prefs,
+    PrefService* incognito_prefs,
+    const FilePath& root_dir,
+    scoped_refptr<ExtensionPrefStore> pref_store,
+    scoped_refptr<ExtensionPrefStore> incognito_pref_store)
     : prefs_(prefs),
+      incognito_prefs_(incognito_prefs),
       install_directory_(root_dir),
-      pref_store_(pref_store) {
+      pref_store_(pref_store),
+      incognito_pref_store_(incognito_pref_store) {
   // TODO(asargent) - Remove this in a couple of months. (See comment above
   // CleanupBadExtensionKeys).
   CleanupBadExtensionKeys(prefs_);
 
   MakePathsRelative();
 
   InitPrefStore();
 }
 
 ExtensionPrefs::~ExtensionPrefs() {}
@@ skipping 656 matching lines @@
                                          Value* data_value) {
   if (!Extension::IdIsValid(extension_id)) {
     NOTREACHED() << "Invalid extension_id " << extension_id;
     return;
   }
   DictionaryValue* extension = GetOrCreateExtensionPref(extension_id);
   extension->Set(key, data_value);
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
-  DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
-  if (dict->HasKey(extension_id)) {
-    dict->Remove(extension_id, NULL);
-    SavePrefsAndNotify();
+  for (int incognito = 0; incognito <= 1; ++incognito) {
+    PrefService* prefs = incognito ? incognito_prefs_ : prefs_;
+    if (!prefs)  // May be null for unit tests.
+      continue;
+    DictionaryValue* dict = prefs->GetMutableDictionary(kExtensionsPref);
+    if (dict->HasKey(extension_id)) {
+      dict->Remove(extension_id, NULL);
+      SavePrefsAndNotify();
+    }
   }
 }
 
 DictionaryValue* ExtensionPrefs::GetOrCreateExtensionPref(
     const std::string& extension_id) {
   DCHECK(Extension::IdIsValid(extension_id));
   DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
   DictionaryValue* extension = NULL;
   if (!dict->GetDictionary(extension_id, &extension)) {
     // Extension pref does not exist, create it.
     extension = new DictionaryValue();
     dict->Set(extension_id, extension);
   }
   return extension;
 }
 
 DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) const {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict)
     return NULL;
   DictionaryValue* extension = NULL;
   dict->GetDictionary(extension_id, &extension);
   return extension;
 }
 
 DictionaryValue* ExtensionPrefs::GetExtensionControlledPrefs(
-    const std::string& extension_id) const {
-  DictionaryValue* extension = GetExtensionPref(extension_id);
-  if (!extension) {
-    NOTREACHED();
+    const std::string& extension_id,
+    bool incognito) const {
+  PrefService* source = incognito ? incognito_prefs_ : prefs_;
+  if (source == NULL)  // May be null for unit tests.
     return NULL;
+  DictionaryValue* source_dict = source->GetMutableDictionary(kExtensionsPref);
+
+  // The user pref store of incognito_prefs_ should have a kExtensionsPref
+  // dictionary. The request must not fall through to the underlying
+  // PrefService.
+  if (incognito &&
+      source_dict == prefs_->GetMutableDictionary(kExtensionsPref)) {
+    DictionaryValue empty;
+    incognito_prefs_->Set(kExtensionsPref, empty);
+    source_dict = source->GetMutableDictionary(kExtensionsPref);
   }
+  DCHECK(!incognito ||
+         source_dict != prefs_->GetMutableDictionary(kExtensionsPref));
+
   DictionaryValue* preferences = NULL;
-  extension->GetDictionary(kPrefPreferences, &preferences);
+  std::string key = extension_id + std::string(".") + kPrefPreferences;
+  if (!source_dict->GetDictionary(key, &preferences)) {
+    source_dict->Set(key, new DictionaryValue);
+    bool success = source_dict->GetDictionary(key, &preferences);
+    DCHECK(success);
+  }
   return preferences;
 }
 
 // Helper function for GetInstalledExtensionsInfo.
 static ExtensionInfo* GetInstalledExtensionInfoImpl(
     DictionaryValue* extension_data,
     DictionaryValue::key_iterator extension_id) {
   DictionaryValue* ext;
   if (!extension_data->GetDictionaryWithoutPathExpansion(*extension_id, &ext)) {
     LOG(WARNING) << "Invalid pref for extension " << *extension_id;
@@ skipping 312 matching lines @@
 
   // Collect the unique extension controlled preference keys of all extensions.
   PrefKeySet ext_controlled_prefs;
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     GetExtensionControlledPrefKeys(*ext_id, &ext_controlled_prefs);
   }
 
   // Store winning preference for each extension controlled preference.
   UpdatePrefStore(ext_controlled_prefs);
-  pref_store_->OnInitializationCompleted();
+  if (pref_store_)
+    pref_store_->OnInitializationCompleted();
 }
 
 const Value* ExtensionPrefs::GetWinningExtensionControlledPrefValue(
-    const std::string& key) const {
+    const std::string& key, bool incognito) const {
   Value *winner = NULL;
   base::Time winners_install_time = base::Time();
 
   ExtensionIdSet extension_ids;
   GetEnabledExtensions(&extension_ids);
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     base::Time extension_install_time = GetInstallTime(*ext_id);
 
     // We do not need to consider extensions that were installed before the
     // most recent extension found that provides the requested preference.
     if (extension_install_time < winners_install_time)
       continue;
 
-    DictionaryValue* preferences = GetExtensionControlledPrefs(*ext_id);
-    Value *value = NULL;
-    if (preferences && preferences->GetWithoutPathExpansion(key, &value)) {
-      // This extension is more recent than the last one providing this pref.
-      winner = value;
-      winners_install_time = extension_install_time;
+    for (int i = 0; i <= (incognito ? 1 : 0); ++i) {
+      DictionaryValue* preferences = GetExtensionControlledPrefs(*ext_id, !!i);
+      Value *value = NULL;
+      if (preferences && preferences->GetWithoutPathExpansion(key, &value)) {
+        // This extension is more recent than the last one providing this pref.
+        winner = value;
+        winners_install_time = extension_install_time;
+      }
     }
   }
 
   return winner;
 }
 
 void ExtensionPrefs::UpdatePrefStore(
     const ExtensionPrefs::PrefKeySet& pref_keys) {
   for (PrefKeySet::const_iterator i = pref_keys.begin();
        i != pref_keys.end(); ++i) {
-    UpdatePrefStore(*i);
+    UpdatePrefStore(*i, false);  // Regular PrefService.
+    UpdatePrefStore(*i, true);   // Incognito PrefService.
   }
 }
 
-void ExtensionPrefs::UpdatePrefStore(const std::string& pref_key) {
-  if (pref_store_ == NULL)
+void ExtensionPrefs::UpdatePrefStore(const std::string& pref_key,
+                                     bool incognito) {
+  scoped_refptr<ExtensionPrefStore> destination =
+      incognito ? incognito_pref_store_ : pref_store_;
+  if (destination == NULL)  // May be null for unit tests.
     return;
   const Value* winning_pref_value =
-      GetWinningExtensionControlledPrefValue(pref_key);
+      GetWinningExtensionControlledPrefValue(pref_key, incognito);
 
   if (winning_pref_value)
-    pref_store_->SetExtensionPref(pref_key, winning_pref_value->DeepCopy());
+    destination->SetExtensionPref(pref_key, winning_pref_value->DeepCopy());
   else
-    pref_store_->RemoveExtensionPref(pref_key);
+    destination->RemoveExtensionPref(pref_key);
 }
 
 void ExtensionPrefs::SetExtensionControlledPref(const std::string& extension_id,
                                                 const std::string& pref_key,
+                                                bool incognito,
                                                 Value* value) {
   scoped_ptr<Value> scoped_value(value);
   DCHECK(pref_service()->FindPreference(pref_key.c_str()))
       << "Extension controlled preference key " << pref_key
       << " not registered.";
+
+  if (incognito && !incognito_pref_store_) {
+    LOG(WARNING) << "Ignoring SetExtensionControlledPref for incognito "
+                 << "preferences, missing an incognito_pref_store.";
+    return;
+  }
+
   DictionaryValue* extension_preferences =
-      GetExtensionControlledPrefs(extension_id);
-
-  if (extension_preferences == NULL) {  // May be pruned when writing to disk.
-    DictionaryValue* extension = GetExtensionPref(extension_id);
-    if (extension == NULL) {
-      LOG(ERROR) << "Extension preference for " << extension_id << " undefined";
-      return;
-    }
-    extension_preferences = new DictionaryValue;
-    extension->Set(kPrefPreferences, extension_preferences);
-  }
+      GetExtensionControlledPrefs(extension_id, incognito);
 
   Value* oldValue = NULL;
   extension_preferences->GetWithoutPathExpansion(pref_key, &oldValue);
   bool modified = !Value::Equals(oldValue, scoped_value.get());
   if (!modified)
     return;
 
   if (scoped_value.get() == NULL)
     extension_preferences->RemoveWithoutPathExpansion(pref_key, NULL);
   else
     extension_preferences->SetWithoutPathExpansion(pref_key,
                                                    scoped_value.release());
-  pref_service()->ScheduleSavePersistentPrefs();
+  if (!incognito)
+    pref_service()->ScheduleSavePersistentPrefs();
 
-  UpdatePrefStore(pref_key);
+  if (!incognito)
+    UpdatePrefStore(pref_key, false);  // Update regular prefs.
+  UpdatePrefStore(pref_key, true);  // Update incognito prefs.
 }
 
 void ExtensionPrefs::GetExtensionControlledPrefKeys(
     const std::string& extension_id, PrefKeySet *out) const {
   DCHECK(out != NULL);
-  DictionaryValue* ext_prefs = GetExtensionControlledPrefs(extension_id);
-  if (ext_prefs) {
-    for (DictionaryValue::key_iterator i = ext_prefs->begin_keys();
-         i != ext_prefs->end_keys(); ++i) {
-      out->insert(*i);
+  for (int incognito = 0; incognito <= 1; ++incognito) {
+    DictionaryValue* ext_prefs = GetExtensionControlledPrefs(extension_id,
+                                                             !!incognito);
+    if (ext_prefs) {
+      for (DictionaryValue::key_iterator i = ext_prefs->begin_keys();
+           i != ext_prefs->end_keys(); ++i) {
+        out->insert(*i);
+      }
     }
   }
 }
 
 // static
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref);
   prefs->RegisterListPref(kExtensionToolbar);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, -1);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate);
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList);
   prefs->RegisterStringPref(kWebStoreLogin, std::string() /* default_value */);
 }