Moved IS_EPHEMERAL flag to extension prefs

chrome/browser/apps/ephemeral_app_service.cc

 // Copyright 2013 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/apps/ephemeral_app_service.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/apps/ephemeral_app_service_factory.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/data_deleter.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/extension_util.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 
 using extensions::Extension;
 using extensions::ExtensionInfo;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionSet;
 using extensions::ExtensionSystem;
 using extensions::InstalledExtensionInfo;
 
@@ skipping 54 matching lines @@
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
       Init();
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       const Extension* extension =
           content::Details<const InstalledExtensionInfo>(details)->extension;
       DCHECK(extension);
-      if (extension->is_ephemeral()) {
+      if (extensions::util::IsEphemeralApp(extension->id(), profile_)) {
         ++ephemeral_app_count_;
         if (ephemeral_app_count_ >= kGarbageCollectAppsTriggerCount)
           TriggerGarbageCollect(
               base::TimeDelta::FromSeconds(kGarbageCollectAppsInstallDelay));
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       DCHECK(extension);
-      if (extension->is_ephemeral())
+      if (extensions::util::IsEphemeralApp(extension->id(), profile_))
         --ephemeral_app_count_;
       break;
     }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       // Ideally we need to know when the extension system is shutting down.
       garbage_collect_apps_timer_.Stop();
       break;
     }
     default:
       NOTREACHED();
-  };
+  }
 }
 
 void EphemeralAppService::Init() {
   InitEphemeralAppCount();
   TriggerGarbageCollect(
       base::TimeDelta::FromSeconds(kGarbageCollectAppsStartupDelay));
 
   garbage_collect_data_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(kGarbageCollectDataStartupDelay),
       this,
       &EphemeralAppService::GarbageCollectData);
 }
 
 void EphemeralAppService::InitEphemeralAppCount() {
   scoped_ptr<ExtensionSet> extensions =
       extensions::ExtensionRegistry::Get(profile_)
           ->GenerateInstalledExtensionsSet();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  DCHECK(prefs);
 
   ephemeral_app_count_ = 0;
   for (ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     const Extension* extension = *it;
-    if (extension->is_ephemeral())
+    if (prefs->IsEphemeralApp(extension->id()))
       ++ephemeral_app_count_;
   }
 }
 
 void EphemeralAppService::TriggerGarbageCollect(const base::TimeDelta& delay) {
   if (!garbage_collect_apps_timer_.IsRunning()) {
     garbage_collect_apps_timer_.Start(
         FROM_HERE,
         delay,
         this,
         &EphemeralAppService::GarbageCollectApps);
   }
 }
 
 void EphemeralAppService::GarbageCollectApps() {
   scoped_ptr<ExtensionSet> extensions =
       extensions::ExtensionRegistry::Get(profile_)
           ->GenerateInstalledExtensionsSet();
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  DCHECK(prefs);
 
   int app_count = 0;
   LaunchTimeAppMap app_launch_times;
   std::set<std::string> remove_app_ids;
 
   // Populate a list of ephemeral apps, ordered by their last launch time.
   for (ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     const Extension* extension = *it;
-    if (!extension->is_ephemeral())
+    if (!prefs->IsEphemeralApp(extension->id()))
       continue;
 
     ++app_count;
 
     // Do not remove ephemeral apps that are running.
     if (!extensions::util::IsExtensionIdle(extension->id(), profile_))
       continue;
 
     base::Time last_launch_time = prefs->GetLastLaunchTime(extension->id());
 
@@ skipping 93 matching lines @@
           info->extension_id,
           &error));
 
       if (extension.get())
         extensions::DataDeleter::StartDeleting(profile_, extension.get());
     }
 
     prefs->RemoveEvictedEphemeralApp(info->extension_id);
   }
 }