Enable incognito_session_only preferences

chrome/browser/extensions/extension_pref_value_map.cc

Index: chrome/browser/extensions/extension_pref_value_map.cc
diff --git a/chrome/browser/extensions/extension_pref_value_map.cc b/chrome/browser/extensions/extension_pref_value_map.cc
index 2fa1483e2ea79cd0128cfd6a2cbcb04ab86f0711..68d185e9f420c31bb6c9000d018612a3bda3bc11 100644
--- a/chrome/browser/extensions/extension_pref_value_map.cc
+++ b/chrome/browser/extensions/extension_pref_value_map.cc
@@ -17,6 +17,8 @@ struct ExtensionPrefValueMap::ExtensionEntry {
   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() {
@@ -65,6 +67,24 @@ bool ExtensionPrefValueMap::CanExtensionControlPref(
   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,
@@ -124,6 +144,8 @@ PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
       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;
@@ -139,6 +161,8 @@ const PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
       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;
@@ -156,6 +180,10 @@ void ExtensionPrefValueMap::GetExtensionControlledKeys(
   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(
@@ -169,11 +197,23 @@ const Value* ExtensionPrefValueMap::GetEffectivePrefValue(
 
   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);
@@ -222,6 +262,15 @@ ExtensionPrefValueMap::GetEffectivePrefValueController(
       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;
 }