Moved IS_EPHEMERAL flag to extension prefs

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 "apps/saved_files_service.h"
 #include "base/files/scoped_temp_dir.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/extension_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/extensions/api/alarms.h"
 #include "content/public/test/browser_test.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/extension_util.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/switches.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notifier_settings.h"
 
 using extensions::Event;
 using extensions::EventRouter;
 using extensions::Extension;
 using extensions::ExtensionInfo;
 using extensions::ExtensionPrefs;
@@ skipping 53 matching lines @@
         extensions::switches::kEventPageSuspendingTime, "10");
   }
 
   base::FilePath GetTestPath(const char* test_path) {
     return test_data_dir_.AppendASCII("platform_apps").AppendASCII(test_path);
   }
 
   const Extension* InstallEphemeralApp(const char* test_path,
                                        Manifest::Location manifest_location) {
     const Extension* extension =
-        InstallExtensionWithSourceAndFlags(
+        InstallEphemeralAppWithSourceAndFlags(
             GetTestPath(test_path),
             1,
             manifest_location,
-            Extension::IS_EPHEMERAL);
+            Extension::NO_FLAGS);
     return extension;
   }
 
   const Extension* InstallEphemeralApp(const char* test_path) {
     return InstallEphemeralApp(test_path, Manifest::INTERNAL);
   }
 
   const Extension* InstallAndLaunchEphemeralApp(const char* test_path) {
     ExtensionTestMessageListener launched_listener("launched", false);
     const Extension* extension = InstallEphemeralApp(test_path);
@@ skipping 130 matching lines @@
   // Verify that messages are not received while the app is inactive.
   LoadAndLaunchPlatformApp("ephemeral_apps/messaging_sender_fail");
   EXPECT_TRUE(result_catcher.GetNextResult());
 }
 
 // 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);
   ASSERT_TRUE(app_v1);
-  ASSERT_TRUE(app_v1->is_ephemeral());
+  ASSERT_TRUE(extensions::util::IsEphemeralApp(app_v1->id(), profile()));
   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.
 
   // Pack version 2 of the app.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   base::FilePath crx_path = temp_dir.path().AppendASCII("temp.crx");
   if (!base::DeleteFile(crx_path, false)) {
@@ skipping 16 matching lines @@
       content::Source<extensions::CrxInstaller>(crx_installer));
   ExtensionService* service =
       ExtensionSystem::Get(browser()->profile())->extension_service();
   EXPECT_TRUE(service->UpdateExtension(app_id, app_v2_path, true,
                                        &crx_installer));
   windowed_observer.Wait();
 
   const Extension* app_v2 = service->GetExtensionById(app_id, false);
   ASSERT_TRUE(app_v2);
   EXPECT_TRUE(app_v2->version()->CompareTo(app_original_version) > 0);
-  EXPECT_TRUE(app_v2->is_ephemeral());
+  EXPECT_TRUE(extensions::util::IsEphemeralApp(app_v2->id(), profile()));
 }
 
 // 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);
   ASSERT_TRUE(app);
 
   // Disable notifications for this app.
   DesktopNotificationService* notification_service =
@@ skipping 103 matching lines @@
   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(browser()->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));
 
   // 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, browser()->profile());
   EXPECT_TRUE(extensions::util::SiteHasIsolatedStorage(
                   site_url, browser()->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());
+}
+
+// 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(browser()->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.
@@ skipping 56 matching lines @@
 
   // 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_;
 }