Disable ephemeral apps after they stop running

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 "apps/app_lifetime_monitor_factory.h"
 #include "base/command_line.h"
+#include "base/message_loop/message_loop.h"
 #include "chrome/browser/apps/ephemeral_app_service_factory.h"
 #include "chrome/browser/chrome_notification_types.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::ExtensionPrefs;
+using extensions::ExtensionRegistry;
 using extensions::ExtensionSet;
 using extensions::ExtensionSystem;
 
 namespace {
 
 // The number of seconds after startup before performing garbage collection
 // of ephemeral apps.
 const int kGarbageCollectAppsStartupDelay = 60;
 
 // The number of seconds after an ephemeral app has been installed before
 // performing garbage collection.
 const int kGarbageCollectAppsInstallDelay = 15;
 
 // When the number of ephemeral apps reaches this count, trigger garbage
 // collection to trim off the least-recently used apps in excess of
 // kMaxEphemeralAppsCount.
 const int kGarbageCollectAppsTriggerCount = 35;
 
+// The number of seconds after an app has stopped running before it will be
+// unloaded and disabled.
+const int kDefaultUnloadAppDelay = 1;
+
+// The number of seconds after startup before unloading inactive ephemeral apps.
+const int kUnloadAppsOnStartupDelay = 5;
+
 }  // namespace
 
 const int EphemeralAppService::kAppInactiveThreshold = 10;
 const int EphemeralAppService::kAppKeepThreshold = 1;
 const int EphemeralAppService::kMaxEphemeralAppsCount = 30;
 
 // static
 EphemeralAppService* EphemeralAppService::Get(Profile* profile) {
   return EphemeralAppServiceFactory::GetForProfile(profile);
 }
 
 EphemeralAppService::EphemeralAppService(Profile* profile)
     : profile_(profile),
       extension_registry_observer_(this),
-      ephemeral_app_count_(-1) {
+      ephemeral_app_count_(-1),
+      unload_idle_app_delay_(kDefaultUnloadAppDelay),
+      weak_ptr_factory_(this) {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableEphemeralApps))
     return;
 
-  extension_registry_observer_.Add(
-      extensions::ExtensionRegistry::Get(profile_));
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<Profile>(profile_));
-  registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
-                 content::Source<Profile>(profile_));
 }
 
 EphemeralAppService::~EphemeralAppService() {
 }
 
 void EphemeralAppService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
       Init();
       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::OnExtensionWillBeInstalled(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     bool is_update,
     bool from_ephemeral,
     const std::string& old_name) {
   if (from_ephemeral) {
     // An ephemeral app was just promoted to a regular installed app.
     --ephemeral_app_count_;
     DCHECK_GE(ephemeral_app_count_, 0);
+    HandleEphemeralAppPromoted(extension);
   } else if (!is_update &&
              extensions::util::IsEphemeralApp(extension->id(), profile_)) {
+    // A new ephemeral app was launched.
     ++ephemeral_app_count_;
     if (ephemeral_app_count_ >= kGarbageCollectAppsTriggerCount) {
       TriggerGarbageCollect(
           base::TimeDelta::FromSeconds(kGarbageCollectAppsInstallDelay));
     }
   }
 }
 
 void EphemeralAppService::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension) {
   if (extensions::util::IsEphemeralApp(extension->id(), profile_)) {
     --ephemeral_app_count_;
     DCHECK_GE(ephemeral_app_count_, 0);
   }
 }
 
+void EphemeralAppService::OnAppStop(Profile* profile,
+                                    const std::string& app_id) {
+  if (!extensions::util::IsEphemeralApp(app_id, profile_))
+    return;
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&EphemeralAppService::UnloadEphemeralApp,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 app_id),
+      base::TimeDelta::FromSeconds(unload_idle_app_delay_));
+}
+
+void EphemeralAppService::OnChromeTerminating() {
+  garbage_collect_apps_timer_.Stop();
+
+  extension_registry_observer_.RemoveAll();
+
+  apps::AppLifetimeMonitor* lifetime_monitor =
+      apps::AppLifetimeMonitorFactory::GetForProfile(profile_);
+  DCHECK(lifetime_monitor);
+  lifetime_monitor->RemoveObserver(this);
+}
+
 void EphemeralAppService::Init() {
   InitEphemeralAppCount();
+
+  apps::AppLifetimeMonitor* lifetime_monitor =
+      apps::AppLifetimeMonitorFactory::GetForProfile(profile_);
+  DCHECK(lifetime_monitor);
+  lifetime_monitor->AddObserver(this);
+
   TriggerGarbageCollect(
       base::TimeDelta::FromSeconds(kGarbageCollectAppsStartupDelay));
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&EphemeralAppService::UnloadEphemeralAppsOnStartup,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::TimeDelta::FromSeconds(kUnloadAppsOnStartupDelay));
 }
 
 void EphemeralAppService::InitEphemeralAppCount() {
   scoped_ptr<ExtensionSet> extensions =
-      extensions::ExtensionRegistry::Get(profile_)
-          ->GenerateInstalledExtensionsSet();
+      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 (prefs->IsEphemeralApp(extension->id()))
       ++ephemeral_app_count_;
   }
 }
 
+void EphemeralAppService::UnloadEphemeralApp(const std::string& app_id) {
+  if (!extensions::util::IsEphemeralApp(app_id, profile_) ||
+      !extensions::util::IsExtensionIdle(app_id, profile_)) {
+    return;
+  }
+
+  // After an ephemeral app has stopped running, unload it from extension
+  // system to prevent all background activity.
+  ExtensionService* service =
+      ExtensionSystem::Get(profile_)->extension_service();
+  DCHECK(service);
+  service->DisableExtension(app_id, Extension::DISABLE_INACTIVE_EPHEMERAL_APP);
+}
+
+void EphemeralAppService::UnloadEphemeralAppsOnStartup() {
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  DCHECK(prefs);
+  ExtensionService* service =
+      ExtensionSystem::Get(profile_)->extension_service();
+  DCHECK(service);
+
+  // Ensure that all inactive ephemeral apps are unloaded from extension system
+  // to prevent all background activity. This is done on startup to catch any
+  // apps that escaped unloading on shutdown.
+  scoped_ptr<ExtensionSet> extensions =
+      ExtensionRegistry::Get(profile_)->GenerateInstalledExtensionsSet();
+  for (ExtensionSet::const_iterator it = extensions->begin();
+       it != extensions->end();
+       ++it) {
+    const Extension* extension = *it;
+    if (prefs->IsEphemeralApp(extension->id()) &&
+        !prefs->IsExtensionDisabled(extension->id()) &&
+        !prefs->IsExtensionRunning(extension->id()) &&
+        extensions::util::IsExtensionIdle(extension->id(), profile_)) {
+      service->DisableExtension(extension->id(),
+                                Extension::DISABLE_INACTIVE_EPHEMERAL_APP);
+    }
+  }
+}
+
+void EphemeralAppService::HandleEphemeralAppPromoted(const Extension* app) {
+  // When ephemeral apps are promoted to regular install apps, remove the
+  // DISABLE_INACTIVE_EPHEMERAL_APP reason and enable the app if there are no
+  // other reasons.
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  DCHECK(prefs);
+
+  int disable_reasons = prefs->GetDisableReasons(app->id());
+  if (disable_reasons & Extension::DISABLE_INACTIVE_EPHEMERAL_APP) {
+    prefs->RemoveDisableReason(app->id(),
+                               Extension::DISABLE_INACTIVE_EPHEMERAL_APP);
+    if (disable_reasons == Extension::DISABLE_INACTIVE_EPHEMERAL_APP)
+      prefs->SetExtensionState(app->id(), Extension::ENABLED);
+  }
+}
+
 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();
+      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) {
@@ skipping 56 matching lines @@
     // Remove ephemeral apps that have been inactive for a while or if the cache
     // is larger than the desired size.
     if (it->first < inactive_threshold || app_count > kMaxEphemeralAppsCount) {
       remove_app_ids->insert(it->second);
       --app_count;
     } else {
       break;
     }
   }
 }