Enable incognito_session_only preferences

chrome/browser/extensions/extension_pref_value_map.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_pref_value_map.h"
 
 #include "base/stl_util-inl.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_value_map.h"
 
 struct ExtensionPrefValueMap::ExtensionEntry {
   // Installation time of the extension.
   base::Time install_time;
   // Whether extension is enabled in the profile.
   bool enabled;
   // Extension controlled preferences for the regular profile.
   PrefValueMap regular_profile_preferences;
   // Persistent extension controlled preferences for the incognito profile,
   // empty for regular profile ExtensionPrefStore.
   PrefValueMap incognito_profile_preferences_persistent;
+  // Session only extension controlled preferences for the incognito profile.
+  // These preferences are deleted when the incognito profile is destroyed.
+  PrefValueMap incognito_profile_preferences_session_only;
 };
 
 ExtensionPrefValueMap::ExtensionPrefValueMap() {
 }
 
 ExtensionPrefValueMap::~ExtensionPrefValueMap() {
   NotifyOfDestruction();
   STLDeleteValues(&entries_);
   entries_.clear();
 }
@@ skipping 28 matching lines @@
   }
 
   ExtensionEntryMap::const_iterator winner =
       GetEffectivePrefValueController(pref_key, incognito, NULL);
   if (winner == entries_.end())
     return true;
 
   return winner->second->install_time <= ext->second->install_time;
 }
 
+void ExtensionPrefValueMap::ClearAllIncognitoSessionOnlyPreferences() {
+  typedef std::set<std::string> KeySet;
+  KeySet deleted_keys;
+
+  ExtensionEntryMap::iterator i;
+  for (i = entries_.begin(); i != entries_.end(); ++i) {
+    PrefValueMap& inc_prefs =
+        i->second->incognito_profile_preferences_session_only;
+    PrefValueMap::iterator j;
+    for (j = inc_prefs.begin(); j != inc_prefs.end(); ++j)
+      deleted_keys.insert(j->first);
+    inc_prefs.Clear();
+  }
+
+  KeySet::iterator k;
+  for (k = deleted_keys.begin(); k != deleted_keys.end(); ++k)
+    NotifyPrefValueChanged(*k);
+}
+
 bool ExtensionPrefValueMap::DoesExtensionControlPref(
     const std::string& extension_id,
     const std::string& pref_key,
     bool incognito) const {
   ExtensionEntryMap::const_iterator winner =
       GetEffectivePrefValueController(pref_key, incognito, NULL);
   if (winner == entries_.end())
     return false;
   return winner->first == extension_id;
 }
@@ skipping 39 matching lines @@
 PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
     const std::string& ext_id,
     extension_prefs_scope::Scope scope) {
   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
   CHECK(i != entries_.end());
   switch (scope) {
     case extension_prefs_scope::kRegular:
       return &(i->second->regular_profile_preferences);
     case extension_prefs_scope::kIncognitoPersistent:
       return &(i->second->incognito_profile_preferences_persistent);
+    case extension_prefs_scope::kIncognitoSessionOnly:
+      return &(i->second->incognito_profile_preferences_session_only);
   }
   NOTREACHED();
   return NULL;
 }
 
 const PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
     const std::string& ext_id,
     extension_prefs_scope::Scope scope) const {
   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
   CHECK(i != entries_.end());
   switch (scope) {
     case extension_prefs_scope::kRegular:
       return &(i->second->regular_profile_preferences);
     case extension_prefs_scope::kIncognitoPersistent:
       return &(i->second->incognito_profile_preferences_persistent);
+    case extension_prefs_scope::kIncognitoSessionOnly:
+      return &(i->second->incognito_profile_preferences_session_only);
   }
   NOTREACHED();
   return NULL;
 }
 
 void ExtensionPrefValueMap::GetExtensionControlledKeys(
     const ExtensionEntry& entry,
     std::set<std::string>* out) const {
   PrefValueMap::const_iterator i;
 
   const PrefValueMap& reg_prefs = entry.regular_profile_preferences;
   for (i = reg_prefs.begin(); i != reg_prefs.end(); ++i)
     out->insert(i->first);
 
   const PrefValueMap& inc_prefs_pers =
       entry.incognito_profile_preferences_persistent;
   for (i = inc_prefs_pers.begin(); i != inc_prefs_pers.end(); ++i)
     out->insert(i->first);
+
+  const PrefValueMap& inc_prefs_session =
+      entry.incognito_profile_preferences_session_only;
+  for (i = inc_prefs_session.begin(); i != inc_prefs_session.end(); ++i)
+    out->insert(i->first);
 }
 
 const Value* ExtensionPrefValueMap::GetEffectivePrefValue(
     const std::string& key,
     bool incognito,
     bool* from_incognito) const {
   ExtensionEntryMap::const_iterator winner =
       GetEffectivePrefValueController(key, incognito, from_incognito);
   if (winner == entries_.end())
     return NULL;
 
   const Value* value = NULL;
   const std::string& ext_id = winner->first;
+
+  // First search for incognito session only preferences.
   if (incognito) {
     const PrefValueMap* prefs = GetExtensionPrefValueMap(
+        ext_id, extension_prefs_scope::kIncognitoSessionOnly);
+    prefs->GetValue(key, &value);
+  }
+
+  // If no incognito session only preference exists, fall back to persistent
+  // incognito preference.
+  if (incognito && !value) {
+    const PrefValueMap* prefs = GetExtensionPrefValueMap(
         ext_id, extension_prefs_scope::kIncognitoPersistent);
     prefs->GetValue(key, &value);
   }
+
+  // Finally consider a regular preference.
   if (!value) {
     const PrefValueMap* prefs = GetExtensionPrefValueMap(
         ext_id, extension_prefs_scope::kRegular);
     prefs->GetValue(key, &value);
   }
   return value;
 }
 
 ExtensionPrefValueMap::ExtensionEntryMap::const_iterator
 ExtensionPrefValueMap::GetEffectivePrefValueController(
@@ skipping 28 matching lines @@
       continue;
 
     prefs = GetExtensionPrefValueMap(
         ext_id, extension_prefs_scope::kIncognitoPersistent);
     if (prefs->GetValue(key, &value)) {
       winner = i;
       winners_install_time = install_time;
       if (from_incognito)
         *from_incognito = true;
     }
+
+    prefs = GetExtensionPrefValueMap(
+        ext_id, extension_prefs_scope::kIncognitoSessionOnly);
+    if (prefs->GetValue(key, &value)) {
+      winner = i;
+      winners_install_time = install_time;
+      if (from_incognito)
+        *from_incognito = true;
+    }
   }
   return winner;
 }
 
 void ExtensionPrefValueMap::AddObserver(
     ExtensionPrefValueMap::Observer* observer) {
   observers_.AddObserver(observer);
 
   // Collect all currently used keys and notify the new observer.
   std::set<std::string> keys;
@@ skipping 25 matching lines @@
 
 void ExtensionPrefValueMap::NotifyPrefValueChanged(const std::string& key) {
   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
                     OnPrefValueChanged(key));
 }
 
 void ExtensionPrefValueMap::NotifyOfDestruction() {
   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
                     OnExtensionPrefValueMapDestruction());
 }