From 9a8c4020cf135d7a9073cf22a69427f1259c5ed5 Mon Sep 17 00:00:00 2001 From: "battre@chromium.org" Date: Tue, 25 Jan 2011 14:25:33 +0000 Subject: Introduce incognito preference settings. This CL introduces preference settings for incognito windows. The semantics are the following: - An extension can set regular preferences as before. These affect regular and incognito windows. - An extension can set regular preferences *and* incognito preferences. In this case, the incognito preferences affect only incognito windows. - If extension A sets reg+incognito, extension B sets reg but no incognito, extension B has higher precedence than A --> B's preferences hold for all regular and incognito windows. - Incognito preferences are never persisted to disk. In order to realize this, the ExtensionPrefs class allows setting regular and incognito extension controlled preferences. It allows creating an incognito version of the PrefService with an independent PrefValueStore. This (incognito) PrefValueStore and the original PrefValueStore share several of their PrefStores (i.e. DefaultPrefStore, CommandLinePrefStore, Configuration PrefStores) but differ in two pref stores: - We maintain two separate ExtensionPrefStores containing the effective preferences for regular and incognito windows. - We maintain two separate user pref stores. The regular JsonPrefStore is expanded by an OverlayPersistentPrefStore that maintains all write-operations in an in-memory overlay. Therefore, incognito changes are not visible in the file-backed JsonPrefStore. The two ExtensionPrefStores retrieve their effective values from a shared ExtensionPrefValueMap. The OffTheRecordProfileImpl provides a request_context_ that uses the new PrefService already. BUG=66027,69057 TEST=unit tests, will be fully testable once the Proxy Settings API allows incognito settings. Review URL: http://codereview.chromium.org/5915004 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@72489 0039d316-1c4b-4281-b951-d872f2087c98 --- .../browser/extensions/extension_pref_value_map.cc | 181 +++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 chrome/browser/extensions/extension_pref_value_map.cc (limited to '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 new file mode 100644 index 0000000..3ae4ca9 --- /dev/null +++ b/chrome/browser/extensions/extension_pref_value_map.cc @@ -0,0 +1,181 @@ +// 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" + +ExtensionPrefValueMap::ExtensionPrefValueMap() { +} + +ExtensionPrefValueMap::~ExtensionPrefValueMap() { + NotifyOfDestruction(); + STLDeleteValues(&entries_); + entries_.clear(); +} + +void ExtensionPrefValueMap::SetExtensionPref(const std::string& ext_id, + const std::string& key, + bool incognito, + Value* value) { + PrefValueMap* prefs = GetExtensionPrefValueMap(ext_id, incognito); + + if (prefs->SetValue(key, value)) + NotifyPrefValueChanged(key); +} + +void ExtensionPrefValueMap::RemoveExtensionPref(const std::string& ext_id, + const std::string& key, + bool incognito) { + PrefValueMap* prefs = GetExtensionPrefValueMap(ext_id, incognito); + if (prefs->RemoveValue(key)) + NotifyPrefValueChanged(key); +} + +void ExtensionPrefValueMap::RegisterExtension(const std::string& ext_id, + const base::Time& install_time, + bool is_enabled) { + if (entries_.find(ext_id) != entries_.end()) + UnregisterExtension(ext_id); + entries_[ext_id] = new ExtensionEntry; + entries_[ext_id]->install_time = install_time; + entries_[ext_id]->enabled = is_enabled; +} + +void ExtensionPrefValueMap::UnregisterExtension(const std::string& ext_id) { + ExtensionEntryMap::iterator i = entries_.find(ext_id); + if (i == entries_.end()) + return; + std::set keys; // keys set by this extension + GetExtensionControlledKeys(*(i->second), &keys); + + delete i->second; + entries_.erase(i); + + NotifyPrefValueChanged(keys); +} + +void ExtensionPrefValueMap::SetExtensionState(const std::string& ext_id, + bool is_enabled) { + ExtensionEntryMap::const_iterator i = entries_.find(ext_id); + CHECK(i != entries_.end()); + if (i->second->enabled == is_enabled) + return; + std::set keys; // keys set by this extension + GetExtensionControlledKeys(*(i->second), &keys); + i->second->enabled = is_enabled; + NotifyPrefValueChanged(keys); +} + +PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap( + const std::string& ext_id, + bool incognito) { + ExtensionEntryMap::const_iterator i = entries_.find(ext_id); + CHECK(i != entries_.end()); + return incognito ? &(i->second->inc_preferences) + : &(i->second->reg_preferences); +} + +const PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap( + const std::string& ext_id, + bool incognito) const { + ExtensionEntryMap::const_iterator i = entries_.find(ext_id); + CHECK(i != entries_.end()); + return incognito ? &(i->second->inc_preferences) + : &(i->second->reg_preferences); +} + +void ExtensionPrefValueMap::GetExtensionControlledKeys( + const ExtensionEntry& entry, + std::set* 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 = entry.inc_preferences; + for (i = inc_prefs.begin(); i != inc_prefs.end(); ++i) + out->insert(i->first); +} + +const Value* ExtensionPrefValueMap::GetEffectivePrefValue( + const std::string& key, + bool incognito) const { + Value *winner = NULL; + base::Time winners_install_time; + + ExtensionEntryMap::const_iterator i; + for (i = entries_.begin(); i != entries_.end(); ++i) { + const std::string& ext_id = i->first; + const base::Time& install_time = i->second->install_time; + const bool enabled = i->second->enabled; + + if (!enabled) + continue; + if (install_time < winners_install_time) + continue; + + Value* value = NULL; + const PrefValueMap* prefs = GetExtensionPrefValueMap(ext_id, false); + if (prefs->GetValue(key, &value)) { + winner = value; + winners_install_time = install_time; + } + + if (!incognito) + continue; + + prefs = GetExtensionPrefValueMap(ext_id, true); + if (prefs->GetValue(key, &value)) { + winner = value; + winners_install_time = install_time; + } + } + return winner; +} + +void ExtensionPrefValueMap::AddObserver( + ExtensionPrefValueMap::Observer* observer) { + observers_.AddObserver(observer); + + // Collect all currently used keys and notify the new observer. + std::set keys; + ExtensionEntryMap::const_iterator i; + for (i = entries_.begin(); i != entries_.end(); ++i) + GetExtensionControlledKeys(*(i->second), &keys); + + std::set::const_iterator j; + for (j = keys.begin(); j != keys.end(); ++j) + observer->OnPrefValueChanged(*j); +} + +void ExtensionPrefValueMap::RemoveObserver( + ExtensionPrefValueMap::Observer* observer) { + observers_.RemoveObserver(observer); +} + +void ExtensionPrefValueMap::NotifyInitializationCompleted() { + FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_, + OnInitializationCompleted()); +} + +void ExtensionPrefValueMap::NotifyPrefValueChanged( + const std::set& keys) { + std::set::const_iterator i; + for (i = keys.begin(); i != keys.end(); ++i) + NotifyPrefValueChanged(*i); +} + +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()); +} -- cgit v1.1