Remove the ability to retain local data of evicted ephemeral apps

extensions/browser/extension_prefs.cc

 // Copyright 2014 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 "extensions/browser/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 164 matching lines @@
 // A preference that indicates whether the extension was installed as an
 // OEM app.
 const char kPrefWasInstalledByOem[] = "was_installed_by_oem";
 
 // Key for Geometry Cache preference.
 const char kPrefGeometryCache[] = "geometry_cache";
 
 // A preference that indicates when an extension is last launched.
 const char kPrefLastLaunchTime[] = "last_launch_time";
 
-// A preference that marks an ephemeral app that was evicted from the cache.
-// Their data is retained and garbage collected when inactive for a long period
-// of time.
-const char kPrefEvictedEphemeralApp[] = "evicted_ephemeral_app";
-
 // A preference indicating whether the extension is an ephemeral app.
 const char kPrefEphemeralApp[] = "ephemeral_app";
 
 // Am installation parameter bundled with an extension.
 const char kPrefInstallParam[] = "install_parameter";
 
 // A list of installed ids and a signature.
 const char kInstallSignature[] = "extensions.install_signature";
 
 // Provider of write access to a dictionary storing extension prefs.
@@ skipping 30 matching lines @@
 }
 
 // Checks if kPrefBlacklist is set to true in the base::DictionaryValue.
 // Return false if the value is false or kPrefBlacklist does not exist.
 // This is used to decide if an extension is blacklisted.
 bool IsBlacklistBitSet(const base::DictionaryValue* ext) {
   bool bool_value;
   return ext->GetBoolean(kPrefBlacklist, &bool_value) && bool_value;
 }
 
-bool IsEvictedEphemeralApp(const base::DictionaryValue* ext) {
-  bool bool_value;
-  return ext->GetBoolean(kPrefEvictedEphemeralApp, &bool_value) && bool_value;
-}
-
 void LoadExtensionControlledPrefs(ExtensionPrefs* prefs,
                                   ExtensionPrefValueMap* value_map,
                                   const std::string& extension_id,
                                   ExtensionPrefsScope scope) {
   std::string scope_string;
   if (!pref_names::ScopeToPrefName(scope, &scope_string))
     return;
   std::string key = extension_id + "." + scope_string;
 
   const base::DictionaryValue* source_dict =
@@ skipping 1013 matching lines @@
   // no longer lists the extension).
   if (!external_uninstall && Manifest::IsExternalLocation(location)) {
     UpdateExtensionPref(extension_id, kPrefState,
                         new base::FundamentalValue(
                             Extension::EXTERNAL_EXTENSION_UNINSTALLED));
     extension_pref_value_map_->SetExtensionState(extension_id, false);
     FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                       observer_list_,
                       OnExtensionStateChanged(extension_id, false));
   } else {
-    if (IsEphemeralApp(extension_id)) {
-      // Keep ephemeral apps around, but mark them as evicted.
-      UpdateExtensionPref(extension_id, kPrefEvictedEphemeralApp,
-                          new base::FundamentalValue(true));
-    } else {
-      DeleteExtensionPrefs(extension_id);
-    }
+    DeleteExtensionPrefs(extension_id);
   }
 }
 
 void ExtensionPrefs::SetExtensionState(const std::string& extension_id,
                                        Extension::State state) {
   UpdateExtensionPref(extension_id, kPrefState,
                       new base::FundamentalValue(state));
   bool enabled = (state == Extension::ENABLED);
   extension_pref_value_map_->SetExtensionState(extension_id, enabled);
   FOR_EACH_OBSERVER(ExtensionPrefsObserver,
@@ skipping 107 matching lines @@
     // Old preferences files may not have kPrefState for component extensions.
     return scoped_ptr<ExtensionInfo>();
   }
 
   if (state_value == Extension::EXTERNAL_EXTENSION_UNINSTALLED) {
     LOG(WARNING) << "External extension with id " << extension_id
                  << " has been uninstalled by the user";
     return scoped_ptr<ExtensionInfo>();
   }
 
-  if (IsEvictedEphemeralApp(ext)) {
-    // Hide evicted ephemeral apps.
-    return scoped_ptr<ExtensionInfo>();
-  }
-
   return GetInstalledInfoHelper(extension_id, ext);
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo>
 ExtensionPrefs::GetInstalledExtensionsInfo() const {
   scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
@@ skipping 156 matching lines @@
       continue;
 
     scoped_ptr<ExtensionInfo> info = GetDelayedInstallInfo(extension_id.key());
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info.Pass();
 }
 
-scoped_ptr<ExtensionPrefs::ExtensionsInfo>
-ExtensionPrefs::GetEvictedEphemeralAppsInfo() const {
-  scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
-
-  const base::DictionaryValue* extensions =
-      prefs_->GetDictionary(pref_names::kExtensions);
-  for (base::DictionaryValue::Iterator extension_id(*extensions);
-       !extension_id.IsAtEnd(); extension_id.Advance()) {
-    const base::DictionaryValue* ext = NULL;
-    if (!Extension::IdIsValid(extension_id.key()) ||
-        !extension_id.value().GetAsDictionary(&ext)) {
-      continue;
-    }
-
-    if (!IsEvictedEphemeralApp(ext))
-      continue;
-
-    scoped_ptr<ExtensionInfo> info =
-        GetInstalledInfoHelper(extension_id.key(), ext);
-    if (info)
-      extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
-  }
-
-  return extensions_info.Pass();
-}
-
-scoped_ptr<ExtensionInfo> ExtensionPrefs::GetEvictedEphemeralAppInfo(
-    const std::string& extension_id) const {
-  const base::DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
-  if (!extension_prefs)
-    return scoped_ptr<ExtensionInfo>();
-
-  if (!IsEvictedEphemeralApp(extension_prefs))
-    return scoped_ptr<ExtensionInfo>();
-
-  return GetInstalledInfoHelper(extension_id, extension_prefs);
-}
-
-void ExtensionPrefs::RemoveEvictedEphemeralApp(
-    const std::string& extension_id) {
-  if (ReadPrefAsBooleanAndReturn(extension_id, kPrefEvictedEphemeralApp))
-    DeleteExtensionPrefs(extension_id);
-}
-
 bool ExtensionPrefs::IsEphemeralApp(const std::string& extension_id) const {
-  // Hide the data of evicted ephemeral apps.
-  if (ReadPrefAsBooleanAndReturn(extension_id, kPrefEvictedEphemeralApp))
-    return false;
-
   if (ReadPrefAsBooleanAndReturn(extension_id, kPrefEphemeralApp))
     return true;
 
   // Ephemerality was previously stored in the creation flags, so we must also
   // check it for backcompatibility.
   return (GetCreationFlags(extension_id) & Extension::IS_EPHEMERAL) != 0;
 }
 
 void ExtensionPrefs::OnEphemeralAppPromoted(const std::string& extension_id) {
   DCHECK(IsEphemeralApp(extension_id));
 
-  ScopedExtensionPrefUpdate update(prefs_, extension_id);
-  update->Set(kPrefEphemeralApp, new base::FundamentalValue(false));
-
-  DCHECK(!IsEvictedEphemeralApp(update.Get()));
-  update->Remove(kPrefEvictedEphemeralApp, NULL);
+  UpdateExtensionPref(
+      extension_id, kPrefEphemeralApp, new base::FundamentalValue(false));
 }
 
 bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefUserDraggedApp);
 }
 
 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
                       new base::FundamentalValue(true));
 }
@@ skipping 531 matching lines @@
                         new base::ListValue);
   }
 
   // If this point has been reached, any pending installs should be considered
   // out of date.
   extension_dict->Remove(kDelayedInstallInfo, NULL);
 
   // Clear state that may be registered from a previous install.
   extension_dict->Remove(EventRouter::kRegisteredEvents, NULL);
 
-  // When evicted ephemeral apps are re-installed, this flag must be reset.
-  extension_dict->Remove(kPrefEvictedEphemeralApp, NULL);
-
   // FYI, all code below here races on sudden shutdown because |extension_dict|,
   // |app_sorting_|, |extension_pref_value_map_|, and (potentially) observers
   // are updated non-transactionally. This is probably not fixable without
   // nested transactional updates to pref dictionaries.
   if (needs_sort_ordinal)
     app_sorting_->EnsureValidOrdinals(extension_id, suggested_page_ordinal);
 
   bool is_enabled = false;
   int initial_state;
   if (extension_dict->GetInteger(kPrefState, &initial_state)) {
     is_enabled = initial_state == Extension::ENABLED;
   }
   bool is_incognito_enabled = IsIncognitoEnabled(extension_id);
 
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions