Optimize promotion of 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 1622 matching lines @@
   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::OnEphemeralAppInstalled(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);
+}
+
 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));
 }
 
 bool ExtensionPrefs::IsFromWebStore(
@@ skipping 474 matching lines @@
       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);
+  extension_dict->Set(kPrefEphemeralApp,
+                      new base::FundamentalValue(is_ephemeral));
 
   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.
@@ skipping 97 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