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;
   // Regular preferences.
   PrefValueMap reg_preferences;
   // Persistent incognito preferences, empty for regular ExtensionPrefStore.
   PrefValueMap inc_preferences_persistent;
+  // Incognito preferences that are bound to a single incognito session.
+  PrefValueMap inc_preferences_session;
 };
 
 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->inc_preferences_session;
+    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);

[Matt Perry, 2011/05/24 22:07:17]

Is it necessarily true that the effective pref value changed? What if the value
being deleted was not the active value? We should only fire the onChanged event
if the effective value changed.

[Bernhard Bauer, 2011/05/24 22:28:06]

Hm, for an extension it might also be interesting to find out when another
extension starts controlling the value, even if it happens to be the same. I
think firing the event more often than necessary shouldn't be as bad as firing
it less often.

[Matt Perry, 2011/05/24 22:35:02]

I agree with that (if the controlling extension changes). Maybe I'm just
confused about how this works, but I'm thinking about this scenario:
1. extensionA sets pref to X.
2. extensionB sets pref to Y, but has lower precedence.
3. extensionB clears pref.

In both step 2 and 3, the pref doesn't actually change, nor does the controlling
extension, since extensionA has precedence. onChanged should only fire in step
1.

[battre, 2011/05/25 11:51:30]

This is exactly what happens.

+}
+
 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->reg_preferences);
     case extension_prefs_scope::kIncognitoPersistent:
       return &(i->second->inc_preferences_persistent);
+    case extension_prefs_scope::kIncognitoSessionOnly:
+      return &(i->second->inc_preferences_session);
   }
   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->reg_preferences);
     case extension_prefs_scope::kIncognitoPersistent:
       return &(i->second->inc_preferences_persistent);
+    case extension_prefs_scope::kIncognitoSessionOnly:
+      return &(i->second->inc_preferences_session);
   }
   NOTREACHED();
   return NULL;
 }
 
 void ExtensionPrefValueMap::GetExtensionControlledKeys(
     const ExtensionEntry& entry,
     std::set<std::string>* out) const {
   PrefValueMap::const_iterator i;
 
   const PrefValueMap& reg_prefs = entry.reg_preferences;
   for (i = reg_prefs.begin(); i != reg_prefs.end(); ++i)
     out->insert(i->first);
 
   const PrefValueMap& inc_prefs_pers = entry.inc_preferences_persistent;
   for (i = inc_prefs_pers.begin(); i != inc_prefs_pers.end(); ++i)
     out->insert(i->first);
+
+  const PrefValueMap& inc_prefs_session = entry.inc_preferences_session;
+  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());
 }