Disable ephemeral apps after they stop running

Ephemeral apps are unloaded and disabled after they stop running to
ensure that they have no background activity while they are cached.

The event router, message service and message center no longer need
special handling for idle ephemeral apps.

BUG=339001,358052
TEST=browser_tests
TBR=dewittj@chromium.org (for removal of code in message_center_settings_controller.cc)

Review URL: https://codereview.chromium.org/344543006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287705 0039d316-1c4b-4281-b951-d872f2087c98

apps/app_lifetime_monitor.h

@@ -31,19 +31,18 @@ class AppLifetimeMonitor : public KeyedService,
   class Observer {
    public:
     // Called when the app starts running.
-    virtual void OnAppStart(Profile* profile, const std::string& app_id) = 0;
+    virtual void OnAppStart(Profile* profile, const std::string& app_id) {}
     // Called when the app becomes active to the user, i.e. it opens a window.
-    virtual void OnAppActivated(Profile* profile,
-                                const std::string& app_id) = 0;
+    virtual void OnAppActivated(Profile* profile, const std::string& app_id) {}
     // Called when the app becomes inactive to the user.
-    virtual void OnAppDeactivated(Profile* profile,
-                                  const std::string& app_id) = 0;
+    virtual void OnAppDeactivated(Profile* profile, const std::string& app_id) {
+    }
     // Called when the app stops running.
-    virtual void OnAppStop(Profile* profile, const std::string& app_id) = 0;
+    virtual void OnAppStop(Profile* profile, const std::string& app_id) {}
     // Called when chrome is about to terminate. This gives observers a chance
     // to do something before the apps shut down. This is a system-wide event
     // so there is no associated profile and app id.
-    virtual void OnChromeTerminating() = 0;
+    virtual void OnChromeTerminating() {}
 
    protected:
     virtual ~Observer() {}

chrome/browser/apps/ephemeral_app_browsertest.h

@@ -21,11 +21,14 @@ class EphemeralAppTestBase : public extensions::PlatformAppBrowserTest {
   static const char kMessagingReceiverApp[];
   static const char kMessagingReceiverAppV2[];
   static const char kDispatchEventTestApp[];
+  static const char kNotificationsTestApp[];
+  static const char kFileSystemTestApp[];
 
   EphemeralAppTestBase();
   virtual ~EphemeralAppTestBase();
 
   virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
+  virtual void SetUpOnMainThread() OVERRIDE;
 
  protected:
   base::FilePath GetTestPath(const char* test_path);
@@ -40,7 +43,10 @@ class EphemeralAppTestBase : public extensions::PlatformAppBrowserTest {
       const base::FilePath& test_dir,
       const base::FilePath& pem_path);
   void PromoteEphemeralApp(const extensions::Extension* app);
+  void DisableEphemeralApp(const extensions::Extension* app,
+                           extensions::Extension::DisableReason disable_reason);
 
+  void CloseAppWaitForUnload(const std::string& app_id);
   void CloseApp(const std::string& app_id);
   void EvictApp(const std::string& app_id);
 };

chrome/browser/apps/ephemeral_app_launcher_browsertest.cc

@@ -4,6 +4,7 @@
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/browser/apps/ephemeral_app_launcher.h"
+#include "chrome/browser/apps/ephemeral_app_service.h"
 #include "chrome/browser/extensions/extension_install_checker.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
@@ -20,6 +21,7 @@
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/management_policy.h"
+#include "extensions/common/switches.h"
 
 using extensions::Extension;
 using extensions::ExtensionPrefs;
@@ -195,10 +197,23 @@ class EphemeralAppLauncherTest : public WebstoreInstallerTest {
   virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE {
     WebstoreInstallerTest::SetUpCommandLine(command_line);
 
+    // Make event pages get suspended immediately.
+    command_line->AppendSwitchASCII(extensions::switches::kEventPageIdleTime,
+                                    "10");
+    command_line->AppendSwitchASCII(
+        extensions::switches::kEventPageSuspendingTime, "10");
+
     // Enable ephemeral apps flag.
     command_line->AppendSwitch(switches::kEnableEphemeralApps);
   }
 
+  virtual void SetUpOnMainThread() OVERRIDE {
+    WebstoreInstallerTest::SetUpOnMainThread();
+
+    // Disable ephemeral apps immediately after they stop running in tests.
+    EphemeralAppService::Get(profile())->set_disable_delay_for_test(0);
+  }
+
   base::FilePath GetTestPath(const char* test_name) {
     return test_data_dir_.AppendASCII("platform_apps/ephemeral_launcher")
         .AppendASCII(test_name);
@@ -270,11 +285,6 @@ class EphemeralAppLauncherTest : public WebstoreInstallerTest {
     if (!app)
       return NULL;
 
-    if (disable_reason == Extension::DISABLE_GREYLIST) {
-      ExtensionPrefs::Get(profile())->SetExtensionBlacklistState(
-          app->id(), extensions::BLACKLISTED_MALWARE);
-    }
-
     ExtensionService* service =
         ExtensionSystem::Get(profile())->extension_service();
     service->DisableExtension(app->id(), disable_reason);
@@ -286,8 +296,8 @@ class EphemeralAppLauncherTest : public WebstoreInstallerTest {
           ->SetDidExtensionEscalatePermissions(app, true);
     }
 
-    EXPECT_FALSE(
-        ExtensionRegistry::Get(profile())->enabled_extensions().Contains(
+    EXPECT_TRUE(
+        ExtensionRegistry::Get(profile())->disabled_extensions().Contains(
             app->id()));
     return app;
   }
@@ -313,6 +323,10 @@ IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTestDisabled, FeatureDisabled) {
 // ephemerally and launched without prompting the user.
 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest,
                        LaunchAppWithNoPermissionWarnings) {
+  content::WindowedNotificationObserver unloaded_signal(
+      extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
+      content::Source<Profile>(profile()));
+
   scoped_refptr<EphemeralAppLauncherForTest> launcher(
       new EphemeralAppLauncherForTest(kDefaultAppId, profile()));
   StartLauncherAndCheckResult(launcher.get(), webstore_install::SUCCESS, true);
@@ -321,6 +335,9 @@ IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest,
   // Apps with no permission warnings should not result in a prompt.
   EXPECT_FALSE(launcher->install_prompt_created());
 
+  // Ephemeral apps are unloaded after they stop running.
+  unloaded_signal.Wait();
+
   // After an app has been installed ephemerally, it can be launched again
   // without installing from the web store.
   RunLaunchTest(kDefaultAppId, webstore_install::SUCCESS, false);
@@ -511,10 +528,16 @@ IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchAppBlockedByPolicy) {
 
 // Verifies that an installed blacklisted app cannot be launched.
 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchBlacklistedApp) {
-  const Extension* app =
-      InstallAndDisableApp(kDefaultAppTestPath, Extension::DISABLE_GREYLIST);
+  const Extension* app = InstallExtension(GetTestPath(kDefaultAppTestPath), 1);
   ASSERT_TRUE(app);
 
+  ExtensionService* service =
+      ExtensionSystem::Get(profile())->extension_service();
+  service->BlacklistExtensionForTest(app->id());
+  ASSERT_TRUE(
+      ExtensionRegistry::Get(profile())->blacklisted_extensions().Contains(
+          app->id()));
+
   RunLaunchTest(app->id(), webstore_install::BLACKLISTED, false);
 }
 

chrome/browser/apps/ephemeral_app_service.cc

@@ -4,7 +4,9 @@
 
 #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"
@@ -44,6 +46,13 @@ const int kGarbageCollectAppsInstallDelay = 15;
 // kMaxEphemeralAppsCount.
 const int kGarbageCollectAppsTriggerCount = 35;
 
+// The number of seconds after an app has stopped running before it will be
+// disabled.
+const int kDefaultDisableAppDelay = 1;
+
+// The number of seconds after startup before disabling inactive ephemeral apps.
+const int kDisableAppsOnStartupDelay = 5;
+
 }  // namespace
 
 const int EphemeralAppService::kAppInactiveThreshold = 10;
@@ -58,17 +67,13 @@ EphemeralAppService* EphemeralAppService::Get(Profile* profile) {
 EphemeralAppService::EphemeralAppService(Profile* profile)
     : profile_(profile),
       extension_registry_observer_(this),
-      ephemeral_app_count_(-1) {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kEnableEphemeralApps))
-    return;
-
-  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
+      app_lifetime_monitor_observer_(this),
+      ephemeral_app_count_(-1),
+      disable_idle_app_delay_(kDefaultDisableAppDelay),
+      weak_ptr_factory_(this) {
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                  content::Source<Profile>(profile_));
-  registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
-                 content::Source<Profile>(profile_));
 }
 
 EphemeralAppService::~EphemeralAppService() {
@@ -119,11 +124,6 @@ void EphemeralAppService::Observe(
       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();
   }
@@ -139,8 +139,10 @@ void EphemeralAppService::OnExtensionWillBeInstalled(
     // 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(
@@ -159,10 +161,46 @@ void EphemeralAppService::OnExtensionUninstalled(
   }
 }
 
+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::DisableEphemeralApp,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 app_id),
+      base::TimeDelta::FromSeconds(disable_idle_app_delay_));
+}
+
+void EphemeralAppService::OnChromeTerminating() {
+  garbage_collect_apps_timer_.Stop();
+
+  extension_registry_observer_.RemoveAll();
+  app_lifetime_monitor_observer_.RemoveAll();
+}
+
 void EphemeralAppService::Init() {
   InitEphemeralAppCount();
+
+  // Start observing.
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
+  app_lifetime_monitor_observer_.Add(
+      apps::AppLifetimeMonitorFactory::GetForProfile(profile_));
+
+  // Execute startup clean up tasks (except during tests).
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType))
+    return;
+
   TriggerGarbageCollect(
       base::TimeDelta::FromSeconds(kGarbageCollectAppsStartupDelay));
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&EphemeralAppService::DisableEphemeralAppsOnStartup,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::TimeDelta::FromSeconds(kDisableAppsOnStartupDelay));
 }
 
 void EphemeralAppService::InitEphemeralAppCount() {
@@ -180,6 +218,76 @@ void EphemeralAppService::InitEphemeralAppCount() {
   }
 }
 
+void EphemeralAppService::DisableEphemeralApp(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 and disable it 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::DisableEphemeralAppsOnStartup() {
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  DCHECK(prefs);
+  ExtensionService* service =
+      ExtensionSystem::Get(profile_)->extension_service();
+  DCHECK(service);
+
+  // Ensure that all inactive ephemeral apps are disabled to prevent all
+  // background activity. This is done on startup to catch any apps that escaped
+  // being disabled 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()))
+      continue;
+
+    // Only V2 apps are installed ephemerally. Remove other ephemeral app types
+    // that were cached before this policy was introduced.
+    if (!extension->is_platform_app()) {
+      service->UninstallExtension(
+          extension->id(),
+          extensions::UNINSTALL_REASON_ORPHANED_EPHEMERAL_EXTENSION,
+          base::Bind(&base::DoNothing),
+          NULL);
+      continue;
+    }
+
+    if (!prefs->HasDisableReason(extension->id(),
+                                 Extension::DISABLE_INACTIVE_EPHEMERAL_APP) &&
+        !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(

chrome/browser/apps/ephemeral_app_service.h

@@ -8,6 +8,8 @@
 #include <map>
 #include <set>
 
+#include "apps/app_lifetime_monitor.h"
+#include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/timer/timer.h"
 #include "components/keyed_service/core/keyed_service.h"
@@ -25,7 +27,8 @@ class ExtensionRegistry;
 // Performs the background garbage collection of ephemeral apps.
 class EphemeralAppService : public KeyedService,
                             public content::NotificationObserver,
-                            public extensions::ExtensionRegistryObserver {
+                            public extensions::ExtensionRegistryObserver,
+                            public apps::AppLifetimeMonitor::Observer {
  public:
   // Returns the instance for the given profile. This is a convenience wrapper
   // around EphemeralAppServiceFactory::GetForProfile.
@@ -39,6 +42,10 @@ class EphemeralAppService : public KeyedService,
 
   int ephemeral_app_count() const { return ephemeral_app_count_; }
 
+  void set_disable_delay_for_test(int delay) {
+    disable_idle_app_delay_ = delay;
+  }
+
   // Constants exposed for testing purposes:
 
   // The number of days of inactivity before an ephemeral app will be removed.
@@ -70,9 +77,18 @@ class EphemeralAppService : public KeyedService,
       const extensions::Extension* extension,
       extensions::UninstallReason reason) OVERRIDE;
 
+  // apps::AppLifetimeMonitor::Observer implementation.
+  virtual void OnAppStop(Profile* profile, const std::string& app_id) OVERRIDE;
+  virtual void OnChromeTerminating() OVERRIDE;
+
   void Init();
   void InitEphemeralAppCount();
 
+  void DisableEphemeralApp(const std::string& app_id);
+  void DisableEphemeralAppsOnStartup();
+
+  void HandleEphemeralAppPromoted(const extensions::Extension* app);
+
   // Garbage collect ephemeral apps.
   void TriggerGarbageCollect(const base::TimeDelta& delay);
   void GarbageCollectApps();
@@ -86,12 +102,20 @@ class EphemeralAppService : public KeyedService,
   ScopedObserver<extensions::ExtensionRegistry,
                  extensions::ExtensionRegistryObserver>
       extension_registry_observer_;
+  ScopedObserver<apps::AppLifetimeMonitor, apps::AppLifetimeMonitor::Observer>
+      app_lifetime_monitor_observer_;
 
   base::OneShotTimer<EphemeralAppService> garbage_collect_apps_timer_;
 
   // The count of cached ephemeral apps.
   int ephemeral_app_count_;
 
+  // Number of seconds before disabling idle ephemeral apps.
+  // Overridden in tests.
+  int disable_idle_app_delay_;
+
+  base::WeakPtrFactory<EphemeralAppService> weak_ptr_factory_;
+
   friend class EphemeralAppServiceTest;
   friend class EphemeralAppServiceBrowserTest;
 

chrome/browser/apps/ephemeral_app_service_browsertest.cc

@@ -50,6 +50,13 @@ class EphemeralAppServiceBrowserTest : public EphemeralAppTestBase {
     ephemeral_service->InitEphemeralAppCount();
   }
 
+  void DisableEphemeralAppsOnStartup() {
+    EphemeralAppService* ephemeral_service =
+        EphemeralAppService::Get(browser()->profile());
+    ASSERT_TRUE(ephemeral_service);
+    ephemeral_service->DisableEphemeralAppsOnStartup();
+  }
+
   std::vector<std::string> app_ids_;
 };
 
@@ -139,7 +146,7 @@ IN_PROC_BROWSER_TEST_F(EphemeralAppServiceBrowserTest, ClearCachedApps) {
       InstallAndLaunchEphemeralApp(kDispatchEventTestApp);
   std::string inactive_app_id = inactive_app->id();
   std::string running_app_id = running_app->id();
-  CloseApp(inactive_app_id);
+  CloseAppWaitForUnload(inactive_app_id);
 
   EphemeralAppService* ephemeral_service =
       EphemeralAppService::Get(browser()->profile());
@@ -157,3 +164,46 @@ IN_PROC_BROWSER_TEST_F(EphemeralAppServiceBrowserTest, ClearCachedApps) {
 
   EXPECT_EQ(1, ephemeral_service->ephemeral_app_count());
 }
+
+// Verify that the service will unload and disable ephemeral apps on startup.
+IN_PROC_BROWSER_TEST_F(EphemeralAppServiceBrowserTest,
+                       DisableEphemeralAppsOnStartup) {
+  const Extension* installed_app = InstallPlatformApp(kNotificationsTestApp);
+  const Extension* running_app =
+      InstallAndLaunchEphemeralApp(kMessagingReceiverApp);
+  const Extension* inactive_app = InstallEphemeralApp(kDispatchEventTestApp);
+  const Extension* disabled_app = InstallEphemeralApp(kFileSystemTestApp);
+  ASSERT_TRUE(installed_app);
+  ASSERT_TRUE(running_app);
+  ASSERT_TRUE(inactive_app);
+  ASSERT_TRUE(disabled_app);
+  DisableEphemeralApp(disabled_app, Extension::DISABLE_PERMISSIONS_INCREASE);
+
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
+  ASSERT_TRUE(registry);
+  EXPECT_TRUE(registry->enabled_extensions().Contains(installed_app->id()));
+  EXPECT_TRUE(registry->enabled_extensions().Contains(running_app->id()));
+  EXPECT_TRUE(registry->enabled_extensions().Contains(inactive_app->id()));
+  EXPECT_TRUE(registry->disabled_extensions().Contains(disabled_app->id()));
+
+  DisableEphemeralAppsOnStartup();
+
+  // Verify that the inactive app is disabled.
+  EXPECT_TRUE(registry->enabled_extensions().Contains(installed_app->id()));
+  EXPECT_TRUE(registry->enabled_extensions().Contains(running_app->id()));
+  EXPECT_TRUE(registry->disabled_extensions().Contains(inactive_app->id()));
+  EXPECT_TRUE(registry->disabled_extensions().Contains(disabled_app->id()));
+
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
+  ASSERT_TRUE(prefs);
+  EXPECT_FALSE(prefs->HasDisableReason(
+      installed_app->id(), Extension::DISABLE_INACTIVE_EPHEMERAL_APP));
+  EXPECT_FALSE(prefs->HasDisableReason(
+      running_app->id(), Extension::DISABLE_INACTIVE_EPHEMERAL_APP));
+  EXPECT_TRUE(prefs->HasDisableReason(
+      inactive_app->id(), Extension::DISABLE_INACTIVE_EPHEMERAL_APP));
+  EXPECT_TRUE(prefs->HasDisableReason(
+      disabled_app->id(), Extension::DISABLE_INACTIVE_EPHEMERAL_APP));
+  EXPECT_TRUE(prefs->HasDisableReason(
+      disabled_app->id(), Extension::DISABLE_PERMISSIONS_INCREASE));
+}

chrome/browser/apps/ephemeral_app_service_factory.cc

@@ -4,6 +4,7 @@
 
 #include "chrome/browser/apps/ephemeral_app_service_factory.h"
 
+#include "apps/app_lifetime_monitor_factory.h"
 #include "chrome/browser/apps/ephemeral_app_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
@@ -29,6 +30,7 @@ EphemeralAppServiceFactory::EphemeralAppServiceFactory()
           "EphemeralAppService",
           BrowserContextDependencyManager::GetInstance()) {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
+  DependsOn(apps::AppLifetimeMonitorFactory::GetInstance());
 }
 
 EphemeralAppServiceFactory::~EphemeralAppServiceFactory() {

chrome/browser/extensions/api/messaging/message_service.cc

@@ -31,7 +31,6 @@
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_system.h"
-#include "extensions/browser/extension_util.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
@@ -216,15 +215,6 @@ void MessageService::OpenChannelToExtension(
     return;
   }
 
-  // Only running ephemeral apps can receive messages. Idle cached ephemeral
-  // apps are invisible and should not be connectable.
-  if (util::IsEphemeralApp(target_extension_id, context) &&
-      util::IsExtensionIdle(target_extension_id, context)) {
-    DispatchOnDisconnect(
-        source, receiver_port_id, kReceivingEndDoesntExistError);
-    return;
-  }
-
   bool is_web_connection = false;
 
   if (source_extension_id != target_extension_id) {

chrome/browser/extensions/extension_service.cc

@@ -163,6 +163,14 @@ void ExtensionService::AddProviderForTesting(
       linked_ptr<extensions::ExternalProviderInterface>(test_provider));
 }
 
+void ExtensionService::BlacklistExtensionForTest(
+    const std::string& extension_id) {
+  ExtensionIdSet blocked;
+  ExtensionIdSet unchanged;
+  blocked.insert(extension_id);
+  UpdateBlockedExtensions(blocked, unchanged);
+}
+
 bool ExtensionService::OnExternalExtensionUpdateUrlFound(
     const std::string& id,
     const std::string& install_parameter,
@@ -845,9 +853,11 @@ void ExtensionService::DisableExtension(
     Extension::DisableReason disable_reason) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // The extension may have been disabled already.
-  if (!IsExtensionEnabled(extension_id))
+  // The extension may have been disabled already. Just add a disable reason.
+  if (!IsExtensionEnabled(extension_id)) {
+    extension_prefs_->AddDisableReason(extension_id, disable_reason);
     return;
+  }
 
   const Extension* extension = GetInstalledExtension(extension_id);
   // |extension| can be NULL if sync disables an extension that is not
@@ -1658,6 +1668,12 @@ void ExtensionService::OnExtensionInstalled(
                               extension->GetType(), 100);
     UMA_HISTOGRAM_ENUMERATION("Extensions.UpdateSource",
                               extension->location(), Manifest::NUM_LOCATIONS);
+
+    // A fully installed app cannot be demoted to an ephemeral app.
+    if ((install_flags & extensions::kInstallFlagIsEphemeral) &&
+        !extension_prefs_->IsEphemeralApp(id)) {
+      install_flags &= ~static_cast<int>(extensions::kInstallFlagIsEphemeral);
+    }
   }
 
   const Extension::State initial_state =
@@ -1837,13 +1853,6 @@ void ExtensionService::PromoteEphemeralApp(
         extension->id(), syncer::StringOrdinal());
   }
 
-  if (!is_from_sync) {
-    // Cached ephemeral apps may be updated and disabled due to permissions
-    // increase. The app can be enabled as the install was user-acknowledged.
-    if (extension_prefs_->DidExtensionEscalatePermissions(extension->id()))
-      GrantPermissionsAndEnableExtension(extension);
-  }
-
   // Remove the ephemeral flags from the preferences.
   extension_prefs_->OnEphemeralAppPromoted(extension->id());
 
@@ -1866,12 +1875,30 @@ void ExtensionService::PromoteEphemeralApp(
       extension->name() /* old name */);
 
   if (registry_->enabled_extensions().Contains(extension->id())) {
+    // If the app is already enabled and loaded, fire the load events to allow
+    // observers to handle the promotion of the ephemeral app.
     content::NotificationService::current()->Notify(
         extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
 
     registry_->TriggerOnLoaded(extension);
+  } else {
+    // Cached ephemeral apps may be updated and disabled due to permissions
+    // increase. The app can be enabled (as long as no other disable reasons
+    // exist) as the install was user-acknowledged.
+    int disable_mask = Extension::DISABLE_NONE;
+    if (!is_from_sync)
+      disable_mask |= Extension::DISABLE_PERMISSIONS_INCREASE;
+
+    int other_disable_reasons =
+        extension_prefs_->GetDisableReasons(extension->id()) & ~disable_mask;
+    if (!other_disable_reasons) {
+      if (extension_prefs_->DidExtensionEscalatePermissions(extension->id()))
+        GrantPermissionsAndEnableExtension(extension);
+      else
+        EnableExtension(extension->id());
+    }
   }
 
   registry_->TriggerOnInstalled(extension, true);

chrome/browser/extensions/extension_service.h

@@ -427,6 +427,9 @@ class ExtensionService
   void AddProviderForTesting(
       extensions::ExternalProviderInterface* test_provider);
 
+  // Simulate an extension being blacklisted for tests.
+  void BlacklistExtensionForTest(const std::string& extension_id);
+
 #if defined(UNIT_TEST)
   void TrackTerminatedExtensionForTest(const extensions::Extension* extension) {
     TrackTerminatedExtension(extension);

chrome/browser/notifications/message_center_settings_controller.cc

@@ -15,7 +15,6 @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/extensions/app_icon_loader_impl.h"
-#include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_types.h"
@@ -34,7 +33,6 @@
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
-#include "extensions/browser/extension_util.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.h"
@@ -234,12 +232,6 @@ void MessageCenterSettingsController::GetNotifierList(
       continue;
     }
 
-    // Exclude cached ephemeral apps that are not currently running.
-    if (extensions::util::IsEphemeralApp(extension->id(), profile) &&
-        extensions::util::IsExtensionIdle(extension->id(), profile)) {
-      continue;
-    }
-
     NotifierId notifier_id(NotifierId::APPLICATION, extension->id());
     notifiers->push_back(new Notifier(
         notifier_id,

chrome/test/data/extensions/platform_apps/ephemeral_apps/dispatch_event/main.js

@@ -6,6 +6,14 @@ chrome.app.runtime.onLaunched.addListener(function() {
   chrome.app.window.create('index.html', {});
 });
 
+chrome.app.runtime.onRestarted.addListener(function() {
+  chrome.test.sendMessage('restarted');
+});
+
 chrome.alarms.onAlarm.addListener(function(alarmInfo) {
   chrome.test.sendMessage('alarm_received');
 });
+
+chrome.runtime.onInstalled.addListener(function() {
+  chrome.test.sendMessage('installed');
+});

extensions/browser/api/app_runtime/app_runtime_api.cc

@@ -32,7 +32,6 @@ void DispatchOnEmbedRequestedEventImpl(
   scoped_ptr<Event> event(
       new Event(app_runtime::OnEmbedRequested::kEventName, args.Pass()));
   event->restrict_to_browser_context = context;
-  event->can_load_ephemeral_apps = true;
   system->event_router()->DispatchEventWithLazyListener(extension_id,
                                                         event.Pass());
 
@@ -52,7 +51,6 @@ void DispatchOnLaunchedEventImpl(const std::string& extension_id,
   scoped_ptr<Event> event(
       new Event(app_runtime::OnLaunched::kEventName, args.Pass()));
   event->restrict_to_browser_context = context;
-  event->can_load_ephemeral_apps = true;
   EventRouter::Get(context)
       ->DispatchEventWithLazyListener(extension_id, event.Pass());
   ExtensionPrefs::Get(context)
@@ -86,7 +84,6 @@ void AppRuntimeEventRouter::DispatchOnRestartedEvent(
   scoped_ptr<Event> event(
       new Event(app_runtime::OnRestarted::kEventName, arguments.Pass()));
   event->restrict_to_browser_context = context;
-  event->can_load_ephemeral_apps = true;
   EventRouter::Get(context)
       ->DispatchEventToExtension(extension->id(), event.Pass());
 }

extensions/browser/event_router.cc

@@ -19,7 +19,6 @@
 #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/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/notification_types.h"
@@ -625,15 +624,6 @@ bool EventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
     BrowserContext* context,
     const Extension* extension,
     const linked_ptr<Event>& event) {
-  if (util::IsEphemeralApp(extension->id(), context) &&
-      !event->can_load_ephemeral_apps) {
-    // Most events can only be dispatched to ephemeral apps that are already
-    // running.
-    ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
-    if (!pm->GetBackgroundHostForExtension(extension->id()))
-      return false;
-  }
-
   if (!CanDispatchEventToBrowserContext(context, extension, event))
     return false;
 
@@ -774,8 +764,7 @@ Event::Event(const std::string& event_name,
     : event_name(event_name),
       event_args(event_args.Pass()),
       restrict_to_browser_context(NULL),
-      user_gesture(EventRouter::USER_GESTURE_UNKNOWN),
-      can_load_ephemeral_apps(false) {
+      user_gesture(EventRouter::USER_GESTURE_UNKNOWN) {
   DCHECK(this->event_args.get());
 }
 
@@ -785,8 +774,7 @@ Event::Event(const std::string& event_name,
     : event_name(event_name),
       event_args(event_args.Pass()),
       restrict_to_browser_context(restrict_to_browser_context),
-      user_gesture(EventRouter::USER_GESTURE_UNKNOWN),
-      can_load_ephemeral_apps(false) {
+      user_gesture(EventRouter::USER_GESTURE_UNKNOWN) {
   DCHECK(this->event_args.get());
 }
 
@@ -801,8 +789,7 @@ Event::Event(const std::string& event_name,
       restrict_to_browser_context(restrict_to_browser_context),
       event_url(event_url),
       user_gesture(user_gesture),
-      filter_info(filter_info),
-      can_load_ephemeral_apps(false) {
+      filter_info(filter_info) {
   DCHECK(this->event_args.get());
 }
 

extensions/browser/event_router.h

@@ -351,12 +351,6 @@ struct Event {
   // this event to be dispatched to non-extension processes, like WebUI.
   WillDispatchCallback will_dispatch_callback;
 
-  // If true, this event will always be dispatched to ephemeral apps, regardless
-  // of whether they are running or inactive. Defaults to false.
-  // Most events can only be dispatched to ephemeral apps that are already
-  // running. Cached ephemeral apps are inactive until launched by the user.
-  bool can_load_ephemeral_apps;
-
   Event(const std::string& event_name,
         scoped_ptr<base::ListValue> event_args);
 

extensions/common/extension.h

@@ -96,7 +96,9 @@ class Extension : public base::RefCountedThreadSafe<Extension> {
     DISABLE_GREYLIST = 1 << 9,
     DISABLE_CORRUPTED = 1 << 10,
     DISABLE_REMOTE_INSTALL = 1 << 11,
-    DISABLE_REASON_LAST = 1 << 12,  // This should always be the last value
+    DISABLE_INACTIVE_EPHEMERAL_APP = 1 << 12,  // Cached ephemeral apps are
+                                               // disabled to prevent activity.
+    DISABLE_REASON_LAST = 1 << 13,  // This should always be the last value
   };
 
   // A base class for parsed manifest data that APIs want to store on