Moved IS_EPHEMERAL flag to extension prefs

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 167 matching lines @@
 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";
 
 // A preference that stores the next threshold for displaying a notification
 // when an extension or app consumes excessive disk space. This will not be
 // set until the extension/app reaches the initial threshold.
 const char kPrefNextStorageThreshold[] = "next_storage_threshold";
@@ skipping 1027 matching lines @@
 }
 
 void ExtensionPrefs::SetKnownDisabled(const ExtensionIdSet& extension_ids) {
   SetExtensionPrefFromContainer(pref_names::kKnownDisabled, extension_ids);
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool blacklisted_for_malware,
+    bool is_ephemeral,
     const syncer::StringOrdinal& page_ordinal,
     const std::string& install_parameter) {
   ScopedExtensionPrefUpdate update(prefs_, extension->id());
   base::DictionaryValue* extension_dict = update.Get();
   const base::Time install_time = time_provider_->GetCurrentTime();
   PopulateExtensionInfoPrefs(extension,
                              install_time,
                              initial_state,
                              blacklisted_for_malware,
+                             is_ephemeral,
                              install_parameter,
                              extension_dict);
   FinishExtensionInfoPrefs(extension->id(), install_time,
                            extension->RequiresSortOrdinal(),
                            page_ordinal, extension_dict);
 }
 
 void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id,
                                             const Manifest::Location& location,
                                             bool external_uninstall) {
   app_sorting_->ClearOrdinals(extension_id);
 
   // For external extensions, we save a preference reminding ourself not to try
   // and install the extension anymore (except when |external_uninstall| is
   // true, which signifies that the registry key was deleted or the pref file
   // 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 {
-    int creation_flags = GetCreationFlags(extension_id);
-    if (creation_flags & Extension::IS_EPHEMERAL) {
+    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);
     }
   }
 }
 
 void ExtensionPrefs::SetExtensionState(const std::string& extension_id,
@@ skipping 175 matching lines @@
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info.Pass();
 }
 
 void ExtensionPrefs::SetDelayedInstallInfo(
     const Extension* extension,
     Extension::State initial_state,
     bool blacklisted_for_malware,
+    bool is_ephemeral,
     DelayReason delay_reason,
     const syncer::StringOrdinal& page_ordinal,
     const std::string& install_parameter) {
   base::DictionaryValue* extension_dict = new base::DictionaryValue();
   PopulateExtensionInfoPrefs(extension,
                              time_provider_->GetCurrentTime(),
                              initial_state,
                              blacklisted_for_malware,
+                             is_ephemeral,
                              install_parameter,
                              extension_dict);
 
   // Add transient data that is needed by FinishDelayedInstallInfo(), but
   // should not be in the final extension prefs. All entries here should have
   // a corresponding Remove() call in FinishDelayedInstallInfo().
   if (extension->RequiresSortOrdinal()) {
     extension_dict->SetString(
         kPrefSuggestedPageOrdinal,
         page_ordinal.IsValid() ? page_ordinal.ToInternalValue()
@@ skipping 138 matching lines @@
     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) {
-  bool evicted_ephemeral_app = false;
-  if (ReadPrefAsBoolean(extension_id,
-                        kPrefEvictedEphemeralApp,
-                        &evicted_ephemeral_app) && evicted_ephemeral_app) {
+  if (ReadPrefAsBooleanAndReturn(extension_id, kPrefEvictedEphemeralApp))
     DeleteExtensionPrefs(extension_id);
-  }
+}
+
+bool ExtensionPrefs::IsEphemeralApp(const std::string& extension_id) const {
+  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;
 }
 
 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 447 matching lines @@
        iter != strings.end(); ++iter) {
     list_of_values->Append(new base::StringValue(*iter));
   }
 }
 
 void ExtensionPrefs::PopulateExtensionInfoPrefs(
     const Extension* extension,
     const base::Time install_time,
     Extension::State initial_state,
     bool blacklisted_for_malware,
+    bool is_ephemeral,
     const std::string& install_parameter,
     base::DictionaryValue* extension_dict) {
   // Leave the state blank for component extensions so that old chrome versions
   // loading new profiles do not fail in GetInstalledExtensionInfo. Older
   // Chrome versions would only check for an omitted state.
   if (initial_state != Extension::ENABLED_COMPONENT)
     extension_dict->Set(kPrefState, new base::FundamentalValue(initial_state));
 
   extension_dict->Set(kPrefLocation,
                       new base::FundamentalValue(extension->location()));
   extension_dict->Set(kPrefCreationFlags,
                       new base::FundamentalValue(extension->creation_flags()));
   extension_dict->Set(kPrefFromWebStore,
                       new base::FundamentalValue(extension->from_webstore()));
   extension_dict->Set(kPrefFromBookmark,
                       new base::FundamentalValue(extension->from_bookmark()));
   extension_dict->Set(
       kPrefWasInstalledByDefault,
       new base::FundamentalValue(extension->was_installed_by_default()));
   extension_dict->Set(
       kPrefWasInstalledByOem,
       new base::FundamentalValue(extension->was_installed_by_oem()));
   extension_dict->Set(kPrefInstallTime,
                       new base::StringValue(
                           base::Int64ToString(install_time.ToInternalValue())));
   if (blacklisted_for_malware)
     extension_dict->Set(kPrefBlacklist, new base::FundamentalValue(true));
 
+  if (is_ephemeral)
+    extension_dict->Set(kPrefEphemeralApp, new base::FundamentalValue(true));
+  else
+    extension_dict->Remove(kPrefEphemeralApp, NULL);
+
   base::FilePath::StringType path = MakePathRelative(install_directory_,
                                                      extension->path());
   extension_dict->Set(kPrefPath, new base::StringValue(path));
   if (!install_parameter.empty()) {
     extension_dict->Set(kPrefInstallParam,
                         new base::StringValue(install_parameter));
   }
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (!Manifest::IsUnpackedLocation(extension->location())) {
@@ skipping 96 matching lines @@
   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