Remove the ability to retain local data of evicted ephemeral apps

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/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 12 matching lines @@
 #include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_change_processor_wrapper_for_test.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notifier_settings.h"
 
 using extensions::AppSyncData;
 using extensions::Event;
 using extensions::EventRouter;
 using extensions::Extension;
-using extensions::ExtensionInfo;
 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";
-const char kRetainDataApp[] = "ephemeral_apps/retain_data";
 
 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)
       return true;
   }
 
   return false;
 }
 
-bool IsAppInExtensionsInfo(const ExtensionPrefs::ExtensionsInfo& ext_info,
-                           const std::string& extension_id) {
-  for (size_t i = 0; i < ext_info.size(); ++i) {
-    ExtensionInfo* info = ext_info.at(i).get();
-    if (info->extension_id == extension_id)
-      return true;
-  }
-
-  return false;
-}
-
 // Saves some parameters from the extension installed notification in order
 // to verify them in tests.
 class InstallObserver : public ExtensionRegistryObserver {
  public:
   struct InstallParameters {
     std::string id;
     bool is_update;
     bool from_ephemeral;
 
     InstallParameters(
@@ skipping 196 matching lines @@
     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());
   }
 
-  void GarbageCollectData() {
-    EphemeralAppService* service =
-        EphemeralAppService::Get(profile());
-    ASSERT_TRUE(service);
-    service->GarbageCollectData();
-  }
-
   const Extension* ReplaceEphemeralApp(const std::string& app_id,
                                        const char* test_path) {
     return UpdateExtensionWaitForIdle(app_id, GetTestPath(test_path), 0);
   }
 
   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);
@@ skipping 212 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_;
 }
 
-// Verify that once evicted from the cache, the data of ephemeral apps will not
-// be deleted.
-IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, RetainData) {
-  // Phase 1 - Install the ephemeral app and write data to various storage.
-  const Extension* app = InstallEphemeralApp(kRetainDataApp);
-  ASSERT_TRUE(app);
-  ASSERT_TRUE(LaunchAppAndRunTest(app, "WriteData")) << message_;
-
-  // Sanity check to ensure that the ReadData tests should pass before the app
-  // is removed.
-  ASSERT_TRUE(LaunchAppAndRunTest(app, "ReadData")) << message_;
-
-  // Remove the app.
-  const std::string app_id = app->id();
-  EvictApp(app->id());
-  app = NULL;
-
-  // The app should be in the list of evicted apps.
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-  ASSERT_TRUE(prefs);
-  scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
-      prefs->GetEvictedEphemeralAppsInfo());
-  EXPECT_TRUE(IsAppInExtensionsInfo(*extensions_info, app_id));
-  scoped_ptr<ExtensionInfo> single_extension_info(
-    prefs->GetEvictedEphemeralAppInfo(app_id));
-  EXPECT_TRUE(single_extension_info.get());
-
-  // The app should not be in the list of installed extensions.
-  extensions_info = prefs->GetInstalledExtensionsInfo();
-  EXPECT_FALSE(IsAppInExtensionsInfo(*extensions_info, app_id));
-  EXPECT_FALSE(prefs->IsEphemeralApp(app_id));
-
-  // Ensure the evicted app is considered to have isolated storage. This will
-  // prevent its data from getting garbage collected by
-  // ExtensionService::GarbageCollectIsolatedStorage().
-  GURL site_url = extensions::util::GetSiteForExtensionId(
-      app_id, profile());
-  EXPECT_TRUE(extensions::util::SiteHasIsolatedStorage(
-                  site_url, profile()));
-
-  // Phase 2 - Reinstall the ephemeral app and verify that data still exists
-  // in the storage.
-  app = InstallEphemeralApp(kRetainDataApp);
-  ASSERT_TRUE(app);
-  EXPECT_TRUE(LaunchAppAndRunTest(app, "ReadData")) << message_;
-
-  // The app should now be in the list of installed extensions, but not in the
-  // list of evicted apps.
-  extensions_info = prefs->GetInstalledExtensionsInfo();
-  EXPECT_TRUE(IsAppInExtensionsInfo(*extensions_info, app_id));
-  extensions_info = prefs->GetEvictedEphemeralAppsInfo();
-  EXPECT_FALSE(IsAppInExtensionsInfo(*extensions_info, app_id));
-  single_extension_info = prefs->GetEvictedEphemeralAppInfo(app_id);
-  EXPECT_FALSE(single_extension_info.get());
-  EXPECT_TRUE(prefs->IsEphemeralApp(app_id));
-}
-
-// Verify that preferences are updated correctly when an evicted ephemeral app
-// is re-installed permanently.
-IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, InstallEvictedEphemeralApp) {
-  const Extension* app = InstallEphemeralApp(kRetainDataApp);
-  ASSERT_TRUE(app);
-
-  // Remove the app.
-  EvictApp(app->id());
-  app = NULL;
-
-  // Install the app permanently.
-  app = InstallPlatformApp(kRetainDataApp);
-  ASSERT_TRUE(app);
-
-  // Verify that preferences are correct.
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-  ASSERT_TRUE(prefs);
-  EXPECT_FALSE(prefs->IsEphemeralApp(app->id()));
-
-  scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
-      prefs->GetEvictedEphemeralAppsInfo());
-  EXPECT_FALSE(IsAppInExtensionsInfo(*extensions_info, app->id()));
-  extensions_info = prefs->GetInstalledExtensionsInfo();
-  EXPECT_TRUE(IsAppInExtensionsInfo(*extensions_info, app->id()));
-}
-
-// Verify that the data of regular installed apps are deleted on uninstall.
-IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, RemoveInstalledData) {
-  // Install the ephemeral app and write data to various storage.
-  const Extension* app = InstallPlatformApp(kRetainDataApp);
-  ASSERT_TRUE(app);
-  ASSERT_TRUE(LaunchAppAndRunTest(app, "WriteData")) << message_;
-
-  // Remove the app.
-  const std::string app_id = app->id();
-  EvictApp(app->id());
-  app = NULL;
-
-  // The app should not be in the preferences.
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-  ASSERT_TRUE(prefs);
-  scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
-      prefs->GetEvictedEphemeralAppsInfo());
-  EXPECT_FALSE(IsAppInExtensionsInfo(*extensions_info, app_id));
-  extensions_info = prefs->GetInstalledExtensionsInfo();
-  EXPECT_FALSE(IsAppInExtensionsInfo(*extensions_info, app_id));
-
-  // Reinstall the app and verify that all data has been reset.
-  app = InstallPlatformApp(kRetainDataApp);
-  ASSERT_TRUE(LaunchAppAndRunTest(app, "DataReset")) << message_;
-}
-
-// Verify that once evicted from the cache, ephemeral apps will remain in
-// extension prefs, but marked as evicted. After garbage collection of data,
-// both their data and preferences should be removed.
-IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, GarbageCollectData) {
-  // Create two apps. Both will be evicted from the cache, but the data of
-  // one will be garbage collected.
-  const Extension* evict_app = InstallEphemeralApp(kRetainDataApp);
-  ASSERT_TRUE(evict_app);
-  ASSERT_TRUE(LaunchAppAndRunTest(evict_app, "WriteData")) << message_;
-  std::string evict_app_id = evict_app->id();
-  EvictApp(evict_app_id);
-  evict_app = NULL;
-
-  const Extension* retain_app = InstallEphemeralApp(kDispatchEventTestApp);
-  ASSERT_TRUE(retain_app);
-  std::string retain_app_id = retain_app->id();
-  EvictApp(retain_app_id);
-  retain_app = NULL;
-
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-  ASSERT_TRUE(prefs);
-
-  // Both apps should be in the list of evicted apps.
-  scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
-      prefs->GetEvictedEphemeralAppsInfo());
-  EXPECT_TRUE(IsAppInExtensionsInfo(*extensions_info, retain_app_id));
-  EXPECT_TRUE(IsAppInExtensionsInfo(*extensions_info, evict_app_id));
-
-  // Set a fake last launch time so that the ephemeral app's data will be
-  // garbage collected.
-  base::Time launch_time =
-      base::Time::Now() - base::TimeDelta::FromDays(
-                              EphemeralAppService::kDataInactiveThreshold + 1);
-  prefs->SetLastLaunchTime(evict_app_id, launch_time);
-  prefs->SetLastLaunchTime(retain_app_id, base::Time::Now());
-
-  // Garbage collect data.
-  GarbageCollectData();
-
-  // The garbage collected app should no longer be in the preferences.
-  extensions_info = prefs->GetEvictedEphemeralAppsInfo();
-  EXPECT_TRUE(IsAppInExtensionsInfo(*extensions_info, retain_app_id));
-  ASSERT_FALSE(IsAppInExtensionsInfo(*extensions_info, evict_app_id));
-
-  // Reinstall the app and verify that all data has been reset.
-  evict_app = InstallEphemeralApp(kRetainDataApp);
-  ASSERT_TRUE(LaunchAppAndRunTest(evict_app, "DataReset")) << message_;
-}
-
 // Checks the process of installing and then promoting an ephemeral app.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteEphemeralApp) {
   InitSyncService();
 
-  const Extension* app = InstallEphemeralApp(kRetainDataApp);
+  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
 
   // 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(), 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) {
   InitSyncService();
 
-  const Extension* app = InstallEphemeralApp(kRetainDataApp);
+  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
 
   // Disable the ephemeral app.
   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));
 
   // Promote to a regular installed app. It should be enabled.
   PromoteEphemeralApp(app);
   VerifyPromotedApp(app->id(), ExtensionRegistry::ENABLED);
 
   scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
   VerifySyncChange(sync_change.get(), true);
 }
 
 // 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(kRetainDataApp);
+  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
 
   // Disable the ephemeral app.
   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));
 
   // Promote to a regular installed app. It should remain disabled.
   PromoteEphemeralApp(app);
   VerifyPromotedApp(app->id(), ExtensionRegistry::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) {
   InitSyncService();
 
-  const Extension* app = InstallEphemeralApp(kRetainDataApp);
+  const Extension* app = InstallEphemeralApp(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 */,
@@ skipping 15 matching lines @@
       kAppLaunchOrdinal));
   EXPECT_TRUE(app_sorting->GetPageOrdinal(app_id).Equals(kPageOrdinal));
 }
 
 // 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(kRetainDataApp);
+  const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
   std::string app_id = app->id();
   app = NULL;
 
   InstallObserver installed_observer(profile());
-  ReplaceEphemeralApp(app_id, kRetainDataApp);
+  ReplaceEphemeralApp(app_id, kNotificationsTestApp);
   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) {
-  const Extension* app = InstallAndLaunchEphemeralApp(kRetainDataApp);
+  const Extension* app = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
   std::string app_id = app->id();
   app = NULL;
 
   // Initiate install.
-  ReplaceEphemeralApp(app_id, kRetainDataApp);
+  ReplaceEphemeralApp(app_id, kNotificationsTestApp);
 
   // 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);
   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);
 }