Disable ephemeral apps after they stop running

chrome/browser/apps/ephemeral_app_browsertest.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 "chrome/browser/apps/ephemeral_app_browsertest.h"
 
 #include <vector>
 
+#include "apps/app_restore_service.h"
 #include "apps/saved_files_service.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
+#include "chrome/browser/apps/ephemeral_app_service.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/extensions/app_sync_data.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_sync_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/alarms.h"
@@ skipping 22 matching lines @@
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionRegistryObserver;
 using extensions::ExtensionSystem;
 using extensions::Manifest;
 
 namespace {
 
 namespace alarms = extensions::api::alarms;
 
-const char kDispatchEventTestApp[] = "ephemeral_apps/dispatch_event";
-const char kNotificationsTestApp[] = "ephemeral_apps/notification_settings";
 const char kFileSystemTestApp[] = "ephemeral_apps/filesystem_retain_entries";
 
 typedef std::vector<message_center::Notifier*> NotifierList;
 
 bool IsNotifierInList(const message_center::NotifierId& notifier_id,
                       const NotifierList& notifiers) {
   for (NotifierList::const_iterator it = notifiers.begin();
        it != notifiers.end(); ++it) {
     const message_center::Notifier* notifier = *it;
     if (notifier->notifier_id == notifier_id)
@@ skipping 48 matching lines @@
 
 }  // namespace
 
 
 // EphemeralAppTestBase:
 
 const char EphemeralAppTestBase::kMessagingReceiverApp[] =
     "ephemeral_apps/messaging_receiver";
 const char EphemeralAppTestBase::kMessagingReceiverAppV2[] =
     "ephemeral_apps/messaging_receiver2";
+const char EphemeralAppTestBase::kDispatchEventTestApp[] =
+    "ephemeral_apps/dispatch_event";
+const char EphemeralAppTestBase::kNotificationsTestApp[] =
+    "ephemeral_apps/notification_settings";
 
 EphemeralAppTestBase::EphemeralAppTestBase() {}
 
 EphemeralAppTestBase::~EphemeralAppTestBase() {}
 
 void EphemeralAppTestBase::SetUpCommandLine(base::CommandLine* command_line) {
   // Skip PlatformAppBrowserTest, which sets different values for the switches
   // below.
   ExtensionBrowserTest::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);
 }
 
+void EphemeralAppTestBase::SetUpOnMainThread() {
+  PlatformAppBrowserTest::SetUpOnMainThread();
+
+  // Unload ephemeral apps immediately after they stop running in tests.
+  EphemeralAppService::Get(profile())->set_unload_delay_for_test(0);
+}
+
 base::FilePath EphemeralAppTestBase::GetTestPath(const char* test_path) {
   return test_data_dir_.AppendASCII("platform_apps").AppendASCII(test_path);
 }
 
 const Extension* EphemeralAppTestBase::InstallEphemeralApp(
     const char* test_path, Manifest::Location manifest_location) {
   const Extension* extension = InstallEphemeralAppWithSourceAndFlags(
       GetTestPath(test_path), 1, manifest_location, Extension::NO_FLAGS);
   EXPECT_TRUE(extension);
   if (extension)
@@ skipping 45 matching lines @@
   extensions::CrxInstaller* crx_installer = NULL;
   content::WindowedNotificationObserver windowed_observer(
       chrome::NOTIFICATION_CRX_INSTALLER_DONE,
       content::Source<extensions::CrxInstaller>(crx_installer));
   ExtensionService* service =
       ExtensionSystem::Get(profile())->extension_service();
   EXPECT_TRUE(service->UpdateExtension(app_id, app_v2_path, true,
                                        &crx_installer));
   windowed_observer.Wait();
 
-  return service->GetExtensionById(app_id, false);
+  return ExtensionRegistry::Get(profile())
+      ->GetExtensionById(app_id, ExtensionRegistry::EVERYTHING);
 }
 
 void EphemeralAppTestBase::PromoteEphemeralApp(
     const extensions::Extension* app) {
   ExtensionService* extension_service =
       ExtensionSystem::Get(profile())->extension_service();
   ASSERT_TRUE(extension_service);
   extension_service->PromoteEphemeralApp(app, false);
 }
 
 void EphemeralAppTestBase::CloseApp(const std::string& app_id) {
-  content::WindowedNotificationObserver event_page_destroyed_signal(
-      chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
-      content::Source<Profile>(profile()));
-
   EXPECT_EQ(1U, GetAppWindowCountForApp(app_id));
   apps::AppWindow* app_window = GetFirstAppWindowForApp(app_id);
   ASSERT_TRUE(app_window);
   CloseAppWindow(app_window);
+}
 
-  event_page_destroyed_signal.Wait();
+void EphemeralAppTestBase::CloseAppWaitForUnload(const std::string& app_id) {
+  // Ephemeral apps are unloaded from extension system after they stop running.
+  content::WindowedNotificationObserver unloaded_signal(
+      chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
+      content::Source<Profile>(profile()));
+  CloseApp(app_id);
+  unloaded_signal.Wait();
 }
 
 void EphemeralAppTestBase::EvictApp(const std::string& app_id) {
   // Uninstall the app, which is what happens when ephemeral apps get evicted
   // from the cache.
   content::WindowedNotificationObserver uninstalled_signal(
       chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
       content::Source<Profile>(profile()));
 
   ExtensionService* service =
       ExtensionSystem::Get(profile())->extension_service();
   ASSERT_TRUE(service);
   service->UninstallExtension(app_id, false, NULL);
 
   uninstalled_signal.Wait();
 }
 
 // EphemeralAppBrowserTest:
 
 class EphemeralAppBrowserTest : public EphemeralAppTestBase {
  protected:
   bool LaunchAppAndRunTest(const Extension* app, const char* test_name) {
+    // Ephemeral apps are unloaded after they are closed. Ensure they are
+    // enabled before launch.
+    ExtensionService* service =
+        ExtensionSystem::Get(profile())->extension_service();
+    service->EnableExtension(app->id());
+
     ExtensionTestMessageListener launched_listener("launched", true);
     LaunchPlatformApp(app);
     if (!launched_listener.WaitUntilSatisfied()) {
       message_ = "Failed to receive launched message from test";
       return false;
     }
 
     ResultCatcher catcher;
     launched_listener.Reply(test_name);
 
     bool result = catcher.GetNextResult();
     message_ = catcher.message();
 
-    CloseApp(app->id());
+    CloseAppWaitForUnload(app->id());
     return result;
   }
 
+  // Verify that the event page of the app has not been loaded.
   void VerifyAppNotLoaded(const std::string& app_id) {
     EXPECT_FALSE(ExtensionSystem::Get(profile())->
         process_manager()->GetBackgroundHostForExtension(app_id));
   }
 
+  // Verify that after ephemeral apps stop running, they reside in extension
+  // system in a disabled and unloaded state.
+  void VerifyInactiveEphemeralApp(const std::string& app_id) {
+    EXPECT_TRUE(
+        ExtensionRegistry::Get(profile())->disabled_extensions().Contains(
+            app_id));
+
+    ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
+    EXPECT_TRUE(prefs->IsExtensionDisabled(app_id));
+    EXPECT_NE(0,
+              prefs->GetDisableReasons(app_id) &
+                  Extension::DISABLE_INACTIVE_EPHEMERAL_APP);
+  }
+
+  // Verify the state of an app that has been promoted from an ephemeral to a
+  // fully installed app.
+  void VerifyPromotedApp(const std::string& app_id,
+                         ExtensionRegistry::IncludeFlag expected_set) {
+    const Extension* app = ExtensionRegistry::Get(profile())
+                               ->GetExtensionById(app_id, expected_set);
+    ASSERT_TRUE(app) << "App not found in expected set: " << expected_set;
+
+    // The app should not be ephemeral.
+    ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
+    ASSERT_TRUE(prefs);
+    EXPECT_FALSE(prefs->IsEphemeralApp(app_id));
+    EXPECT_EQ(0,
+              prefs->GetDisableReasons(app_id) &
+                  Extension::DISABLE_INACTIVE_EPHEMERAL_APP);
+
+    // Check sort ordinals.
+    extensions::AppSorting* app_sorting = prefs->app_sorting();
+    EXPECT_TRUE(app_sorting->GetAppLaunchOrdinal(app_id).IsValid());
+    EXPECT_TRUE(app_sorting->GetPageOrdinal(app_id).IsValid());
+  }
+
+  // Dispatch a fake alarm event to the app.
   void DispatchAlarmEvent(EventRouter* event_router,
                           const std::string& app_id) {
     alarms::Alarm dummy_alarm;
     dummy_alarm.name = "test_alarm";
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(dummy_alarm.ToValue().release());
     scoped_ptr<Event> event(new Event(alarms::OnAlarm::kEventName,
                                       args.Pass()));
 
     event_router->DispatchEventToExtension(app_id, event.Pass());
   }
 
+  // Simulates the scenario where an app is installed, via the normal
+  // installation route, on top of an ephemeral app. This can occur due to race
+  // conditions.
   const Extension* ReplaceEphemeralApp(const std::string& app_id,
-                                       const char* test_path) {
-    return UpdateExtensionWaitForIdle(app_id, GetTestPath(test_path), 0);
+                                       const char* test_path,
+                                       int expected_enabled_change) {
+    return UpdateExtensionWaitForIdle(
+        app_id, GetTestPath(test_path), expected_enabled_change);
   }
 
-  void VerifyPromotedApp(const std::string& app_id,
-                         ExtensionRegistry::IncludeFlag expected_set) {
-    const Extension* app = ExtensionRegistry::Get(profile())->GetExtensionById(
-        app_id, expected_set);
+  void DisableEphemeralApp(const Extension* app,
+                           Extension::DisableReason disable_reason) {
+    ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
+
+    // Disabling due to a permissions increase also involves setting the
+    // DidExtensionEscalatePermissions flag.
+    if (disable_reason == Extension::DISABLE_PERMISSIONS_INCREASE)
+      prefs->SetDidExtensionEscalatePermissions(app, true);
+
+    ExtensionSystem::Get(profile())->extension_service()->DisableExtension(
+        app->id(), disable_reason);
+
+    ASSERT_TRUE(
+        ExtensionRegistry::Get(profile())->disabled_extensions().Contains(
+            app->id()));
+  }
+
+  void PromoteEphemeralAppAndVerify(
+      const Extension* app,
+      ExtensionRegistry::IncludeFlag expected_set) {
     ASSERT_TRUE(app);
 
-    // The app should not be ephemeral.
+    // Ephemeral apps should not be synced.
+    scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
+    EXPECT_FALSE(sync_change.get());
+
+    // Promote the app to a regular installed app.
+    InstallObserver installed_observer(profile());
+    PromoteEphemeralApp(app);
+    VerifyPromotedApp(app->id(), expected_set);
+
+    // Check the notification parameters.
+    const InstallObserver::InstallParameters& params =
+        installed_observer.Last();
+    EXPECT_EQ(app->id(), params.id);
+    EXPECT_TRUE(params.is_update);
+    EXPECT_TRUE(params.from_ephemeral);
+
+    // The installation should now be synced.
+    sync_change = GetFirstSyncChangeForApp(app->id());
+    VerifySyncChange(sync_change.get(),
+                     expected_set == ExtensionRegistry::ENABLED);
+  }
+
+  void PromoteEphemeralAppFromSyncAndVerify(
+      const Extension* app,
+      bool enable_from_sync,
+      ExtensionRegistry::IncludeFlag expected_set) {
+    ASSERT_TRUE(app);
+
+    // Simulate an install from sync.
+    const syncer::StringOrdinal kAppLaunchOrdinal("x");
+    const syncer::StringOrdinal kPageOrdinal("y");
+    AppSyncData app_sync_data(*app,
+                              enable_from_sync,
+                              false /* incognito enabled */,
+                              false /* remote install */,
+                              kAppLaunchOrdinal,
+                              kPageOrdinal,
+                              extensions::LAUNCH_TYPE_REGULAR);
+
+    std::string app_id = app->id();
+    app = NULL;
+
+    ExtensionSyncService* sync_service = ExtensionSyncService::Get(profile());
+    sync_service->ProcessAppSyncData(app_sync_data);
+
+    // Verify the installation.
+    VerifyPromotedApp(app_id, expected_set);
+
+    // The sort ordinals from sync should not be overridden.
     ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-    ASSERT_TRUE(prefs);
-    EXPECT_FALSE(prefs->IsEphemeralApp(app_id));
-
-    // Check sort ordinals.
     extensions::AppSorting* app_sorting = prefs->app_sorting();
-    EXPECT_TRUE(app_sorting->GetAppLaunchOrdinal(app_id).IsValid());
-    EXPECT_TRUE(app_sorting->GetPageOrdinal(app_id).IsValid());
+    EXPECT_TRUE(
+        app_sorting->GetAppLaunchOrdinal(app_id).Equals(kAppLaunchOrdinal));
+    EXPECT_TRUE(app_sorting->GetPageOrdinal(app_id).Equals(kPageOrdinal));
   }
 
   void InitSyncService() {
     ExtensionSyncService* sync_service = ExtensionSyncService::Get(profile());
     sync_service->MergeDataAndStartSyncing(
         syncer::APPS,
         syncer::SyncDataList(),
         scoped_ptr<syncer::SyncChangeProcessor>(
             new syncer::SyncChangeProcessorWrapperForTest(
                 &mock_sync_processor_)),
@@ skipping 15 matching lines @@
   }
 
   void VerifySyncChange(const AppSyncData* sync_change, bool expect_enabled) {
     ASSERT_TRUE(sync_change);
     EXPECT_TRUE(sync_change->page_ordinal().IsValid());
     EXPECT_TRUE(sync_change->app_launch_ordinal().IsValid());
     EXPECT_FALSE(sync_change->uninstalled());
     EXPECT_EQ(expect_enabled, sync_change->extension_sync_data().enabled());
   }
 
+  void TestInstallEvent(bool close_app) {
+    ExtensionTestMessageListener first_msg_listener(false);
+    const Extension* app = InstallAndLaunchEphemeralApp(kDispatchEventTestApp);
+    ASSERT_TRUE(app);
+
+    // When an ephemeral app is first added, it should not receive the
+    // onInstalled event, hence the first message received from the test should
+    // be "launched" and not "installed".
+    ASSERT_TRUE(first_msg_listener.WaitUntilSatisfied());
+    EXPECT_EQ(std::string("launched"), first_msg_listener.message());
+
+    if (close_app)
+      CloseAppWaitForUnload(app->id());
+
+    // When installed permanently, the app should receive the onInstalled event.
+    ExtensionTestMessageListener install_listener("installed", false);
+    PromoteEphemeralApp(app);
+    ASSERT_TRUE(install_listener.WaitUntilSatisfied());
+  }
+
+ private:
   syncer::FakeSyncChangeProcessor mock_sync_processor_;
 };
 
 // Verify that ephemeral apps can be launched and receive system events when
 // they are running. Once they are inactive they should not receive system
 // events.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, EventDispatchWhenLaunched) {
   const Extension* extension =
       InstallAndLaunchEphemeralApp(kDispatchEventTestApp);
   ASSERT_TRUE(extension);
 
   // Send a fake alarm event to the app and verify that a response is
   // received.
   EventRouter* event_router = EventRouter::Get(profile());
   ASSERT_TRUE(event_router);
 
   ExtensionTestMessageListener alarm_received_listener("alarm_received", false);
   DispatchAlarmEvent(event_router, extension->id());
   ASSERT_TRUE(alarm_received_listener.WaitUntilSatisfied());
 
-  CloseApp(extension->id());
-
-  // The app needs to be launched once in order to have the onAlarm() event
-  // registered.
-  ASSERT_TRUE(event_router->ExtensionHasEventListener(
-      extension->id(), alarms::OnAlarm::kEventName));
+  CloseAppWaitForUnload(extension->id());
 
   // Dispatch the alarm event again and verify that the event page did not get
   // loaded for the app.
   DispatchAlarmEvent(event_router, extension->id());
   VerifyAppNotLoaded(extension->id());
 }
 
 // Verify that ephemeral apps will receive messages while they are running.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, ReceiveMessagesWhenLaunched) {
   const Extension* receiver =
       InstallAndLaunchEphemeralApp(kMessagingReceiverApp);
   ASSERT_TRUE(receiver);
 
   // Verify that messages are received while the app is running.
   ExtensionApiTest::ResultCatcher result_catcher;
   LoadAndLaunchPlatformApp("ephemeral_apps/messaging_sender_success",
                            "Launched");
   EXPECT_TRUE(result_catcher.GetNextResult());
 
-  CloseApp(receiver->id());
+  CloseAppWaitForUnload(receiver->id());
 
   // Verify that messages are not received while the app is inactive.
   LoadAndLaunchPlatformApp("ephemeral_apps/messaging_sender_fail", "Launched");
   EXPECT_TRUE(result_catcher.GetNextResult());
 }
 
+// Verifies that the chrome.runtime.onInstalled() event is received by a running
+// ephemeral app only when it is promoted.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
+                       InstallEventReceivedWhileRunning) {
+  TestInstallEvent(false /* close app */);
+}
+
+// Verifies that when an idle ephemeral app is promoted, it will be loaded to
+// receive the chrome.runtime.onInstalled() event.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, InstallEventReceivedWhileIdle) {
+  TestInstallEvent(true /* close app */);
+}
+
+// Verifies that the chrome.runtime.onRestarted() event is received by an
+// ephemeral app.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, RestartEventReceived) {
+  const Extension* app = InstallAndLaunchEphemeralApp(kDispatchEventTestApp);
+  ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
+
+  // Fake ephemeral app running before restart.
+  ExtensionSystem::Get(profile())->extension_service()->EnableExtension(
+      app->id());
+  ASSERT_TRUE(ExtensionRegistry::Get(profile())->enabled_extensions().Contains(
+      app->id()));
+  ExtensionPrefs::Get(profile())->SetExtensionRunning(app->id(), true);
+
+  ExtensionTestMessageListener restart_listener("restarted", false);
+  apps::AppRestoreService::Get(profile())->HandleStartup(true);
+  EXPECT_TRUE(restart_listener.WaitUntilSatisfied());
+}
+
 // Verify that an updated ephemeral app will still have its ephemeral flag
 // enabled.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, UpdateEphemeralApp) {
-  const Extension* app_v1 = InstallEphemeralApp(kMessagingReceiverApp);
+  const Extension* app_v1 = InstallAndLaunchEphemeralApp(kMessagingReceiverApp);
   ASSERT_TRUE(app_v1);
+  CloseAppWaitForUnload(app_v1->id());
+  VerifyInactiveEphemeralApp(app_v1->id());
+
   std::string app_id = app_v1->id();
   base::Version app_original_version = *app_v1->version();
-  app_v1 = NULL; // The extension object will be destroyed during update.
+  app_v1 = NULL;  // The extension object will be destroyed during update.
 
   // Update to version 2 of the app.
   InstallObserver installed_observer(profile());
-  const Extension* app_v2 = UpdateEphemeralApp(
-      app_id, GetTestPath(kMessagingReceiverAppV2),
-      GetTestPath(kMessagingReceiverApp).ReplaceExtension(
-          FILE_PATH_LITERAL(".pem")));
+  const Extension* app_v2 =
+      UpdateEphemeralApp(app_id,
+                         GetTestPath(kMessagingReceiverAppV2),
+                         GetTestPath(kMessagingReceiverApp)
+                             .ReplaceExtension(FILE_PATH_LITERAL(".pem")));
 
   // Check the notification parameters.
   const InstallObserver::InstallParameters& params = installed_observer.Last();
   EXPECT_EQ(app_id, params.id);
   EXPECT_TRUE(params.is_update);
   EXPECT_FALSE(params.from_ephemeral);
 
-  // The ephemeral flag should still be enabled.
+  // The ephemeral flag should still be set.
   ASSERT_TRUE(app_v2);
-  EXPECT_TRUE(app_v2->version()->CompareTo(app_original_version) > 0);
+  EXPECT_GT(app_v2->version()->CompareTo(app_original_version), 0);
   EXPECT_TRUE(extensions::util::IsEphemeralApp(app_v2->id(), profile()));
+
+  // The app should still be disabled in extension system.
+  VerifyInactiveEphemeralApp(app_id);
 }
 
 // Verify that if notifications have been disabled for an ephemeral app, it will
 // remain disabled even after being evicted from the cache.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, StickyNotificationSettings) {
-  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
 
   // Disable notifications for this app.
   DesktopNotificationService* notification_service =
       DesktopNotificationServiceFactory::GetForProfile(profile());
   ASSERT_TRUE(notification_service);
 
   message_center::NotifierId notifier_id(
       message_center::NotifierId::APPLICATION, app->id());
   EXPECT_TRUE(notification_service->IsNotifierEnabled(notifier_id));
   notification_service->SetNotifierEnabled(notifier_id, false);
   EXPECT_FALSE(notification_service->IsNotifierEnabled(notifier_id));
 
   // Remove the app.
+  CloseAppWaitForUnload(app->id());
   EvictApp(app->id());
 
   // Reinstall the ephemeral app and verify that notifications remain disabled.
   app = InstallEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
   message_center::NotifierId reinstalled_notifier_id(
       message_center::NotifierId::APPLICATION, app->id());
   EXPECT_FALSE(notification_service->IsNotifierEnabled(
       reinstalled_notifier_id));
 }
 
 // Verify that only running ephemeral apps will appear in the Notification
 // Settings UI. Inactive, cached ephemeral apps should not appear.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
                        IncludeRunningEphemeralAppsInNotifiers) {
   message_center::NotifierSettingsProvider* settings_provider =
       message_center::MessageCenter::Get()->GetNotifierSettingsProvider();
-  // TODO(tmdiep): Remove once notifications settings are supported across
-  // all platforms. This test will fail for Linux GTK.
-  if (!settings_provider)
-    return;
+  DCHECK(settings_provider);
 
   const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
   message_center::NotifierId notifier_id(
       message_center::NotifierId::APPLICATION, app->id());
 
   // Since the ephemeral app is running, it should be included in the list
   // of notifiers to show in the UI.
   NotifierList notifiers;
   STLElementDeleter<NotifierList> notifier_deleter(&notifiers);
 
   settings_provider->GetNotifierList(&notifiers);
   EXPECT_TRUE(IsNotifierInList(notifier_id, notifiers));
   STLDeleteElements(&notifiers);
 
   // Close the ephemeral app.
-  CloseApp(app->id());
+  CloseAppWaitForUnload(app->id());
 
   // Inactive ephemeral apps should not be included in the list of notifiers to
   // show in the UI.
   settings_provider->GetNotifierList(&notifiers);
   EXPECT_FALSE(IsNotifierInList(notifier_id, notifiers));
 }
 
 // Verify that ephemeral apps will have no ability to retain file entries after
 // close. Normal retainEntry behavior for installed apps is tested in
 // FileSystemApiTest.
@@ skipping 22 matching lines @@
   // flushed.
   std::vector<apps::SavedFileEntry> file_entries =
       apps::SavedFilesService::Get(profile())
           ->GetAllFileEntries(app->id());
   EXPECT_TRUE(file_entries.empty());
 
   // The second test verifies that the file cannot be reopened.
   ASSERT_TRUE(LaunchAppAndRunTest(app, "RestoreRetainedFile")) << message_;
 }
 
-// Checks the process of installing and then promoting an ephemeral app.
-IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteEphemeralApp) {
+// Checks the process of launching an ephemeral app and then promoting the app
+// while it is running.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteAppWhileRunning) {
   InitSyncService();
 
-  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
 
-  // Ephemeral apps should not be synced.
-  scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
-  EXPECT_FALSE(sync_change.get());
+  PromoteEphemeralAppAndVerify(app, ExtensionRegistry::ENABLED);
 
-  // Promote the app to a regular installed app.
-  InstallObserver installed_observer(profile());
-  PromoteEphemeralApp(app);
+  // Ensure that the app is not unloaded and disabled after it is closed.
+  CloseApp(app->id());
   VerifyPromotedApp(app->id(), ExtensionRegistry::ENABLED);
-
-  // Check the notification parameters.
-  const InstallObserver::InstallParameters& params = installed_observer.Last();
-  EXPECT_EQ(app->id(), params.id);
-  EXPECT_TRUE(params.is_update);
-  EXPECT_TRUE(params.from_ephemeral);
-
-  // The installation should now be synced.
-  sync_change = GetFirstSyncChangeForApp(app->id());
-  VerifySyncChange(sync_change.get(), true);
 }
 
-// Verifies that promoting an ephemeral app will enable it.
-IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteEphemeralAppAndEnable) {
+// Checks the process of launching an ephemeral app and then promoting the app
+// while it is idle.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteAppWhileIdle) {
   InitSyncService();
 
-  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
+  VerifyInactiveEphemeralApp(app->id());
 
-  // Disable the ephemeral app due to a permissions increase. This also involves
-  // setting the DidExtensionEscalatePermissions flag.
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-  prefs->SetDidExtensionEscalatePermissions(app, true);
-  ExtensionService* service =
-      ExtensionSystem::Get(profile())->extension_service();
-  service->DisableExtension(app->id(), Extension::DISABLE_PERMISSIONS_INCREASE);
-  ASSERT_TRUE(ExtensionRegistry::Get(profile())->
-      GetExtensionById(app->id(), ExtensionRegistry::DISABLED));
+  PromoteEphemeralAppAndVerify(app, ExtensionRegistry::ENABLED);
+}
 
-  // Promote to a regular installed app. It should be enabled.
-  PromoteEphemeralApp(app);
-  VerifyPromotedApp(app->id(), ExtensionRegistry::ENABLED);
-  EXPECT_FALSE(prefs->DidExtensionEscalatePermissions(app->id()));
+// Verifies that promoting an ephemeral app that was disabled due to a
+// permissions increase will enable it.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteAppAndGrantPermissions) {
+  InitSyncService();
 
-  scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
-  VerifySyncChange(sync_change.get(), true);
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
+  ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
+  DisableEphemeralApp(app, Extension::DISABLE_PERMISSIONS_INCREASE);
+
+  PromoteEphemeralAppAndVerify(app, ExtensionRegistry::ENABLED);
+  EXPECT_FALSE(ExtensionPrefs::Get(profile())
+                   ->DidExtensionEscalatePermissions(app->id()));
 }
 
 // Verifies that promoting an ephemeral app that has unsupported requirements
 // will not enable it.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
                        PromoteUnsupportedEphemeralApp) {
   InitSyncService();
 
-  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
+  DisableEphemeralApp(app, Extension::DISABLE_UNSUPPORTED_REQUIREMENT);
 
-  // Disable the ephemeral app.
+  // When promoted to a regular installed app, it should remain disabled.
+  PromoteEphemeralAppAndVerify(app, ExtensionRegistry::DISABLED);
+}
+
+// Verifies that promoting an ephemeral app that is blacklisted will not enable
+// it.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
+                       PromoteBlacklistedEphemeralApp) {
+  InitSyncService();
+
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
+  ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
+
   ExtensionService* service =
       ExtensionSystem::Get(profile())->extension_service();
-  service->DisableExtension(
-      app->id(), Extension::DISABLE_UNSUPPORTED_REQUIREMENT);
-  ASSERT_TRUE(ExtensionRegistry::Get(profile())->
-      GetExtensionById(app->id(), ExtensionRegistry::DISABLED));
+  service->BlacklistExtensionForTest(app->id());
+  ASSERT_TRUE(
+      ExtensionRegistry::Get(profile())->blacklisted_extensions().Contains(
+          app->id()));
 
-  // Promote to a regular installed app. It should remain disabled.
-  PromoteEphemeralApp(app);
-  VerifyPromotedApp(app->id(), ExtensionRegistry::DISABLED);
+  // When promoted to a regular installed app, it should remain blacklisted.
+  PromoteEphemeralAppAndVerify(app, ExtensionRegistry::BLACKLISTED);
 
+  // The app should be synced, but disabled.
   scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
   VerifySyncChange(sync_change.get(), false);
 }
 
-// Checks the process of promoting an ephemeral app from sync.
-IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteEphemeralAppFromSync) {
+// Checks the process of promoting an ephemeral app from sync while the app is
+// running.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
+                       PromoteAppFromSyncWhileRunning) {
   InitSyncService();
 
-  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
-  std::string app_id = app->id();
 
-  // Simulate an install from sync.
-  const syncer::StringOrdinal kAppLaunchOrdinal("x");
-  const syncer::StringOrdinal kPageOrdinal("y");
-  AppSyncData app_sync_data(
-      *app,
-      true /* enabled */,
-      false /* incognito enabled */,
-      false /* remote install */,
-      kAppLaunchOrdinal,
-      kPageOrdinal,
-      extensions::LAUNCH_TYPE_REGULAR);
+  PromoteEphemeralAppFromSyncAndVerify(app, true, ExtensionRegistry::ENABLED);
 
-  ExtensionSyncService* sync_service = ExtensionSyncService::Get(profile());
-  sync_service->ProcessAppSyncData(app_sync_data);
+  // Ensure that the app is not unloaded and disabled after it is closed.
+  CloseApp(app->id());
+  VerifyPromotedApp(app->id(), ExtensionRegistry::ENABLED);
+}
 
-  // Verify the installation.
-  VerifyPromotedApp(app_id, ExtensionRegistry::ENABLED);
+// Checks the process of promoting an ephemeral app from sync while the app is
+// idle.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteAppFromSyncWhileIdle) {
+  InitSyncService();
 
-  // The sort ordinals from sync should not be overridden.
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-  extensions::AppSorting* app_sorting = prefs->app_sorting();
-  EXPECT_TRUE(app_sorting->GetAppLaunchOrdinal(app_id).Equals(
-      kAppLaunchOrdinal));
-  EXPECT_TRUE(app_sorting->GetPageOrdinal(app_id).Equals(kPageOrdinal));
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
+  ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
+  VerifyInactiveEphemeralApp(app->id());
+
+  PromoteEphemeralAppFromSyncAndVerify(app, true, ExtensionRegistry::ENABLED);
+}
+
+// Checks the process of promoting an ephemeral app from sync, where the app
+// from sync is disabled, and the ephemeral app is running.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
+                       PromoteDisabledAppFromSyncWhileRunning) {
+  InitSyncService();
+
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
+  ASSERT_TRUE(app);
+
+  PromoteEphemeralAppFromSyncAndVerify(app, false, ExtensionRegistry::DISABLED);
+}
+
+// Checks the process of promoting an ephemeral app from sync, where the app
+// from sync is disabled, and the ephemeral app is idle.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
+                       PromoteDisabledAppFromSyncWhileIdle) {
+  InitSyncService();
+
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
+  ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
+  VerifyInactiveEphemeralApp(app->id());
+
+  PromoteEphemeralAppFromSyncAndVerify(app, false, ExtensionRegistry::DISABLED);
 }
 
 // In most cases, ExtensionService::PromoteEphemeralApp() will be called to
 // permanently install an ephemeral app. However, there may be cases where an
 // install occurs through the usual route of installing from the Web Store (due
 // to race conditions). Ensure that the app is still installed correctly.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
                        ReplaceEphemeralAppWithInstalledApp) {
-  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
+  InitSyncService();
+
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
+  CloseAppWaitForUnload(app->id());
   std::string app_id = app->id();
   app = NULL;
 
   InstallObserver installed_observer(profile());
-  ReplaceEphemeralApp(app_id, kNotificationsTestApp);
+  ReplaceEphemeralApp(app_id, kNotificationsTestApp, 1);
   VerifyPromotedApp(app_id, ExtensionRegistry::ENABLED);
 
   // Check the notification parameters.
   const InstallObserver::InstallParameters& params = installed_observer.Last();
   EXPECT_EQ(app_id, params.id);
   EXPECT_TRUE(params.is_update);
   EXPECT_TRUE(params.from_ephemeral);
 }
 
 // This is similar to ReplaceEphemeralAppWithInstalledApp, but installs will
 // be delayed until the app is idle.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
                        ReplaceEphemeralAppWithDelayedInstalledApp) {
+  InitSyncService();
+
   const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
   std::string app_id = app->id();
   app = NULL;
 
   // Initiate install.
-  ReplaceEphemeralApp(app_id, kNotificationsTestApp);
+  ReplaceEphemeralApp(app_id, kNotificationsTestApp, 0);
 
   // The delayed installation will occur when the ephemeral app is closed.
   content::WindowedNotificationObserver installed_signal(
       chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED,
       content::Source<Profile>(profile()));
   InstallObserver installed_observer(profile());
-  CloseApp(app_id);
+  CloseAppWaitForUnload(app_id);
   installed_signal.Wait();
   VerifyPromotedApp(app_id, ExtensionRegistry::ENABLED);
 
   // Check the notification parameters.
   const InstallObserver::InstallParameters& params = installed_observer.Last();
   EXPECT_EQ(app_id, params.id);
   EXPECT_TRUE(params.is_update);
   EXPECT_TRUE(params.from_ephemeral);
 }
 
+// Verifies that an installed app cannot turn into an ephemeral app as result of
+// race conditions, i.e. an ephemeral app can be promoted to an installed app,
+// but not vice versa.
+IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
+                       ReplaceInstalledAppWithEphemeralApp) {
+  const Extension* app = InstallPlatformApp(kNotificationsTestApp);
+  ASSERT_TRUE(app);
+  std::string app_id = app->id();
+  app = NULL;
+
+  EXPECT_FALSE(extensions::util::IsEphemeralApp(app_id, profile()));
+  app =
+      InstallEphemeralAppWithSourceAndFlags(GetTestPath(kNotificationsTestApp),
+                                            0,
+                                            Manifest::INTERNAL,
+                                            Extension::NO_FLAGS);
+  EXPECT_FALSE(extensions::util::IsEphemeralApp(app_id, profile()));
+}
+
 // Ephemerality was previously encoded by the Extension::IS_EPHEMERAL creation
 // flag. This was changed to an "ephemeral_app" property. Check that the prefs
 // are handled correctly.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest,
                        ExtensionPrefBackcompatibility) {
   // Ensure that apps with the old prefs are recognized as ephemeral.
   const Extension* app =
       InstallExtensionWithSourceAndFlags(GetTestPath(kNotificationsTestApp),
                                          1,
                                          Manifest::INTERNAL,
                                          Extension::IS_EPHEMERAL);
   ASSERT_TRUE(app);
   EXPECT_TRUE(extensions::util::IsEphemeralApp(app->id(), profile()));
 
   // Ensure that when the app is promoted to an installed app, the bit in the
   // creation flags is cleared.
   PromoteEphemeralApp(app);
   EXPECT_FALSE(extensions::util::IsEphemeralApp(app->id(), profile()));
 
   int creation_flags =
       ExtensionPrefs::Get(profile())->GetCreationFlags(app->id());
   EXPECT_EQ(0, creation_flags & Extension::IS_EPHEMERAL);
 }