Home | History | Annotate | Download | only in browser 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "extensions/browser/extension_pref_value_map.h"
      6 
      7 #include "base/prefs/pref_value_map.h"
      8 #include "base/stl_util.h"
      9 #include "base/values.h"
     10 
     11 using extensions::ExtensionPrefsScope;
     12 
     13 struct ExtensionPrefValueMap::ExtensionEntry {
     14   // Installation time of the extension.
     15   base::Time install_time;
     16   // Whether extension is enabled in the profile.
     17   bool enabled;
     18   // Whether the extension has access to the incognito profile.
     19   bool incognito_enabled;
     20   // Extension controlled preferences for the regular profile.
     21   PrefValueMap regular_profile_preferences;
     22   // Extension controlled preferences that should *only* apply to the regular
     23   // profile.
     24   PrefValueMap regular_only_profile_preferences;
     25   // Persistent extension controlled preferences for the incognito profile,
     26   // empty for regular profile ExtensionPrefStore.
     27   PrefValueMap incognito_profile_preferences_persistent;
     28   // Session only extension controlled preferences for the incognito profile.
     29   // These preferences are deleted when the incognito profile is destroyed.
     30   PrefValueMap incognito_profile_preferences_session_only;
     31 };
     32 
     33 ExtensionPrefValueMap::ExtensionPrefValueMap() : destroyed_(false) {
     34 }
     35 
     36 ExtensionPrefValueMap::~ExtensionPrefValueMap() {
     37   if (!destroyed_) {
     38     NotifyOfDestruction();
     39     destroyed_ = true;
     40   }
     41   STLDeleteValues(&entries_);
     42   entries_.clear();
     43 }
     44 
     45 void ExtensionPrefValueMap::Shutdown() {
     46   NotifyOfDestruction();
     47   destroyed_ = true;
     48 }
     49 
     50 void ExtensionPrefValueMap::SetExtensionPref(const std::string& ext_id,
     51                                              const std::string& key,
     52                                              ExtensionPrefsScope scope,
     53                                              base::Value* value) {
     54   PrefValueMap* prefs = GetExtensionPrefValueMap(ext_id, scope);
     55 
     56   if (prefs->SetValue(key, value))
     57     NotifyPrefValueChanged(key);
     58 }
     59 
     60 void ExtensionPrefValueMap::RemoveExtensionPref(
     61     const std::string& ext_id,
     62     const std::string& key,
     63     ExtensionPrefsScope scope) {
     64   PrefValueMap* prefs = GetExtensionPrefValueMap(ext_id, scope);
     65   if (prefs->RemoveValue(key))
     66     NotifyPrefValueChanged(key);
     67 }
     68 
     69 bool ExtensionPrefValueMap::CanExtensionControlPref(
     70     const std::string& extension_id,
     71     const std::string& pref_key,
     72     bool incognito) const {
     73   ExtensionEntryMap::const_iterator ext = entries_.find(extension_id);
     74   if (ext == entries_.end()) {
     75     NOTREACHED();
     76     return false;
     77   }
     78 
     79   if (incognito && !ext->second->incognito_enabled)
     80     return false;
     81 
     82   ExtensionEntryMap::const_iterator winner =
     83       GetEffectivePrefValueController(pref_key, incognito, NULL);
     84   if (winner == entries_.end())
     85     return true;
     86 
     87   return winner->second->install_time <= ext->second->install_time;
     88 }
     89 
     90 void ExtensionPrefValueMap::ClearAllIncognitoSessionOnlyPreferences() {
     91   typedef std::set<std::string> KeySet;
     92   KeySet deleted_keys;
     93 
     94   ExtensionEntryMap::iterator i;
     95   for (i = entries_.begin(); i != entries_.end(); ++i) {
     96     PrefValueMap& inc_prefs =
     97         i->second->incognito_profile_preferences_session_only;
     98     PrefValueMap::iterator j;
     99     for (j = inc_prefs.begin(); j != inc_prefs.end(); ++j)
    100       deleted_keys.insert(j->first);
    101     inc_prefs.Clear();
    102   }
    103 
    104   KeySet::iterator k;
    105   for (k = deleted_keys.begin(); k != deleted_keys.end(); ++k)
    106     NotifyPrefValueChanged(*k);
    107 }
    108 
    109 bool ExtensionPrefValueMap::DoesExtensionControlPref(
    110     const std::string& extension_id,
    111     const std::string& pref_key,
    112     bool* from_incognito) const {
    113   bool incognito = (from_incognito != NULL);
    114   ExtensionEntryMap::const_iterator winner =
    115       GetEffectivePrefValueController(pref_key, incognito, from_incognito);
    116   if (winner == entries_.end())
    117     return false;
    118   return winner->first == extension_id;
    119 }
    120 
    121 void ExtensionPrefValueMap::RegisterExtension(const std::string& ext_id,
    122                                               const base::Time& install_time,
    123                                               bool is_enabled,
    124                                               bool is_incognito_enabled) {
    125   if (entries_.find(ext_id) == entries_.end()) {
    126     entries_[ext_id] = new ExtensionEntry;
    127 
    128     // Only update the install time if the extension is newly installed.
    129     entries_[ext_id]->install_time = install_time;
    130   }
    131 
    132   entries_[ext_id]->enabled = is_enabled;
    133   entries_[ext_id]->incognito_enabled = is_incognito_enabled;
    134 }
    135 
    136 void ExtensionPrefValueMap::UnregisterExtension(const std::string& ext_id) {
    137   ExtensionEntryMap::iterator i = entries_.find(ext_id);
    138   if (i == entries_.end())
    139     return;
    140   std::set<std::string> keys;  // keys set by this extension
    141   GetExtensionControlledKeys(*(i->second), &keys);
    142 
    143   delete i->second;
    144   entries_.erase(i);
    145 
    146   NotifyPrefValueChanged(keys);
    147 }
    148 
    149 void ExtensionPrefValueMap::SetExtensionState(const std::string& ext_id,
    150                                               bool is_enabled) {
    151   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
    152   // This may happen when sync sets the extension state for an
    153   // extension that is not installed.
    154   if (i == entries_.end())
    155     return;
    156   if (i->second->enabled == is_enabled)
    157     return;
    158   std::set<std::string> keys;  // keys set by this extension
    159   GetExtensionControlledKeys(*(i->second), &keys);
    160   i->second->enabled = is_enabled;
    161   NotifyPrefValueChanged(keys);
    162 }
    163 
    164 void ExtensionPrefValueMap::SetExtensionIncognitoState(
    165     const std::string& ext_id,
    166     bool is_incognito_enabled) {
    167   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
    168   // This may happen when sync sets the extension state for an
    169   // extension that is not installed.
    170   if (i == entries_.end())
    171     return;
    172   if (i->second->incognito_enabled == is_incognito_enabled)
    173     return;
    174   std::set<std::string> keys;  // keys set by this extension
    175   GetExtensionControlledKeys(*(i->second), &keys);
    176   i->second->incognito_enabled = is_incognito_enabled;
    177   NotifyPrefValueChanged(keys);
    178 }
    179 
    180 PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
    181     const std::string& ext_id,
    182     ExtensionPrefsScope scope) {
    183   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
    184   CHECK(i != entries_.end());
    185   switch (scope) {
    186     case extensions::kExtensionPrefsScopeRegular:
    187       return &(i->second->regular_profile_preferences);
    188     case extensions::kExtensionPrefsScopeRegularOnly:
    189       return &(i->second->regular_only_profile_preferences);
    190     case extensions::kExtensionPrefsScopeIncognitoPersistent:
    191       return &(i->second->incognito_profile_preferences_persistent);
    192     case extensions::kExtensionPrefsScopeIncognitoSessionOnly:
    193       return &(i->second->incognito_profile_preferences_session_only);
    194   }
    195   NOTREACHED();
    196   return NULL;
    197 }
    198 
    199 const PrefValueMap* ExtensionPrefValueMap::GetExtensionPrefValueMap(
    200     const std::string& ext_id,
    201     ExtensionPrefsScope scope) const {
    202   ExtensionEntryMap::const_iterator i = entries_.find(ext_id);
    203   CHECK(i != entries_.end());
    204   switch (scope) {
    205     case extensions::kExtensionPrefsScopeRegular:
    206       return &(i->second->regular_profile_preferences);
    207     case extensions::kExtensionPrefsScopeRegularOnly:
    208       return &(i->second->regular_only_profile_preferences);
    209     case extensions::kExtensionPrefsScopeIncognitoPersistent:
    210       return &(i->second->incognito_profile_preferences_persistent);
    211     case extensions::kExtensionPrefsScopeIncognitoSessionOnly:
    212       return &(i->second->incognito_profile_preferences_session_only);
    213   }
    214   NOTREACHED();
    215   return NULL;
    216 }
    217 
    218 void ExtensionPrefValueMap::GetExtensionControlledKeys(
    219     const ExtensionEntry& entry,
    220     std::set<std::string>* out) const {
    221   PrefValueMap::const_iterator i;
    222 
    223   const PrefValueMap& regular_prefs = entry.regular_profile_preferences;
    224   for (i = regular_prefs.begin(); i != regular_prefs.end(); ++i)
    225     out->insert(i->first);
    226 
    227   const PrefValueMap& regular_only_prefs =
    228       entry.regular_only_profile_preferences;
    229   for (i = regular_only_prefs.begin(); i != regular_only_prefs.end(); ++i)
    230     out->insert(i->first);
    231 
    232   const PrefValueMap& inc_prefs_pers =
    233       entry.incognito_profile_preferences_persistent;
    234   for (i = inc_prefs_pers.begin(); i != inc_prefs_pers.end(); ++i)
    235     out->insert(i->first);
    236 
    237   const PrefValueMap& inc_prefs_session =
    238       entry.incognito_profile_preferences_session_only;
    239   for (i = inc_prefs_session.begin(); i != inc_prefs_session.end(); ++i)
    240     out->insert(i->first);
    241 }
    242 
    243 const base::Value* ExtensionPrefValueMap::GetEffectivePrefValue(
    244     const std::string& key,
    245     bool incognito,
    246     bool* from_incognito) const {
    247   ExtensionEntryMap::const_iterator winner =
    248       GetEffectivePrefValueController(key, incognito, from_incognito);
    249   if (winner == entries_.end())
    250     return NULL;
    251 
    252   const base::Value* value = NULL;
    253   const std::string& ext_id = winner->first;
    254 
    255   // First search for incognito session only preferences.
    256   if (incognito) {
    257     DCHECK(winner->second->incognito_enabled);
    258     const PrefValueMap* prefs = GetExtensionPrefValueMap(
    259         ext_id, extensions::kExtensionPrefsScopeIncognitoSessionOnly);
    260     prefs->GetValue(key, &value);
    261     if (value)
    262       return value;
    263 
    264     // If no incognito session only preference exists, fall back to persistent
    265     // incognito preference.
    266     prefs = GetExtensionPrefValueMap(
    267         ext_id,
    268         extensions::kExtensionPrefsScopeIncognitoPersistent);
    269     prefs->GetValue(key, &value);
    270     if (value)
    271       return value;
    272   } else {
    273     // Regular-only preference.
    274     const PrefValueMap* prefs = GetExtensionPrefValueMap(
    275         ext_id, extensions::kExtensionPrefsScopeRegularOnly);
    276     prefs->GetValue(key, &value);
    277     if (value)
    278       return value;
    279   }
    280 
    281   // Regular preference.
    282   const PrefValueMap* prefs = GetExtensionPrefValueMap(
    283       ext_id, extensions::kExtensionPrefsScopeRegular);
    284   prefs->GetValue(key, &value);
    285   return value;
    286 }
    287 
    288 ExtensionPrefValueMap::ExtensionEntryMap::const_iterator
    289 ExtensionPrefValueMap::GetEffectivePrefValueController(
    290     const std::string& key,
    291     bool incognito,
    292     bool* from_incognito) const {
    293   ExtensionEntryMap::const_iterator winner = entries_.end();
    294   base::Time winners_install_time;
    295 
    296   ExtensionEntryMap::const_iterator i;
    297   for (i = entries_.begin(); i != entries_.end(); ++i) {
    298     const std::string& ext_id = i->first;
    299     const base::Time& install_time = i->second->install_time;
    300     const bool enabled = i->second->enabled;
    301     const bool incognito_enabled = i->second->incognito_enabled;
    302 
    303     if (!enabled)
    304       continue;
    305     if (install_time < winners_install_time)
    306       continue;
    307     if (incognito && !incognito_enabled)
    308       continue;
    309 
    310     const base::Value* value = NULL;
    311     const PrefValueMap* prefs = GetExtensionPrefValueMap(
    312         ext_id, extensions::kExtensionPrefsScopeRegular);
    313     if (prefs->GetValue(key, &value)) {
    314       winner = i;
    315       winners_install_time = install_time;
    316       if (from_incognito)
    317         *from_incognito = false;
    318     }
    319 
    320     if (!incognito) {
    321       const PrefValueMap* prefs = GetExtensionPrefValueMap(
    322           ext_id, extensions::kExtensionPrefsScopeRegularOnly);
    323       if (prefs->GetValue(key, &value)) {
    324         winner = i;
    325         winners_install_time = install_time;
    326         if (from_incognito)
    327           *from_incognito = false;
    328       }
    329       // Ignore the following prefs, because they're incognito-only.
    330       continue;
    331     }
    332 
    333     prefs = GetExtensionPrefValueMap(
    334         ext_id, extensions::kExtensionPrefsScopeIncognitoPersistent);
    335     if (prefs->GetValue(key, &value)) {
    336       winner = i;
    337       winners_install_time = install_time;
    338       if (from_incognito)
    339         *from_incognito = true;
    340     }
    341 
    342     prefs = GetExtensionPrefValueMap(
    343         ext_id, extensions::kExtensionPrefsScopeIncognitoSessionOnly);
    344     if (prefs->GetValue(key, &value)) {
    345       winner = i;
    346       winners_install_time = install_time;
    347       if (from_incognito)
    348         *from_incognito = true;
    349     }
    350   }
    351   return winner;
    352 }
    353 
    354 void ExtensionPrefValueMap::AddObserver(
    355     ExtensionPrefValueMap::Observer* observer) {
    356   observers_.AddObserver(observer);
    357 
    358   // Collect all currently used keys and notify the new observer.
    359   std::set<std::string> keys;
    360   ExtensionEntryMap::const_iterator i;
    361   for (i = entries_.begin(); i != entries_.end(); ++i)
    362     GetExtensionControlledKeys(*(i->second), &keys);
    363 
    364   std::set<std::string>::const_iterator j;
    365   for (j = keys.begin(); j != keys.end(); ++j)
    366     observer->OnPrefValueChanged(*j);
    367 }
    368 
    369 void ExtensionPrefValueMap::RemoveObserver(
    370     ExtensionPrefValueMap::Observer* observer) {
    371   observers_.RemoveObserver(observer);
    372 }
    373 
    374 std::string ExtensionPrefValueMap::GetExtensionControllingPref(
    375     const std::string& pref_key) const {
    376   ExtensionEntryMap::const_iterator winner =
    377       GetEffectivePrefValueController(pref_key, false, NULL);
    378   if (winner == entries_.end())
    379     return std::string();
    380   return winner->first;
    381 }
    382 
    383 void ExtensionPrefValueMap::NotifyInitializationCompleted() {
    384   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
    385                     OnInitializationCompleted());
    386 }
    387 
    388 void ExtensionPrefValueMap::NotifyPrefValueChanged(
    389     const std::set<std::string>& keys) {
    390   std::set<std::string>::const_iterator i;
    391   for (i = keys.begin(); i != keys.end(); ++i)
    392     NotifyPrefValueChanged(*i);
    393 }
    394 
    395 void ExtensionPrefValueMap::NotifyPrefValueChanged(const std::string& key) {
    396   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
    397                     OnPrefValueChanged(key));
    398 }
    399 
    400 void ExtensionPrefValueMap::NotifyOfDestruction() {
    401   FOR_EACH_OBSERVER(ExtensionPrefValueMap::Observer, observers_,
    402                     OnExtensionPrefValueMapDestruction());
    403 }
    404