Do not assign launch ordinals to 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/app_restore_service.h"
 #include "apps/saved_files_service.h"
@@ skipping 281 matching lines @@
     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 properties of ephemeral apps.
+  void VerifyEphemeralApp(const std::string& app_id) {
+    EXPECT_TRUE(extensions::util::IsEphemeralApp(app_id, profile()));
+
+    // Ephemeral apps should not be synced.
+    scoped_ptr<AppSyncData> sync_change = GetLastSyncChangeForApp(app_id);
+    EXPECT_FALSE(sync_change.get());
+
+    // Ephemeral apps should not be assigned ordinals.
+    extensions::AppSorting* app_sorting =
+        ExtensionPrefs::Get(profile())->app_sorting();
+    EXPECT_FALSE(app_sorting->GetAppLaunchOrdinal(app_id).IsValid());
+    EXPECT_FALSE(app_sorting->GetPageOrdinal(app_id).IsValid());
+  }
+
   // 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,
@@ skipping 61 matching lines @@
 
     ASSERT_TRUE(
         ExtensionRegistry::Get(profile())->disabled_extensions().Contains(
             app->id()));
   }
 
   void PromoteEphemeralAppAndVerify(
       const Extension* app,
       ExtensionRegistry::IncludeFlag expected_set) {
     ASSERT_TRUE(app);
-
-    // Ephemeral apps should not be synced.
-    scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
-    EXPECT_FALSE(sync_change.get());
+    VerifyEphemeralApp(app->id());
 
     // 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());
+    scoped_ptr<AppSyncData> sync_change = GetLastSyncChangeForApp(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);
+    VerifyEphemeralApp(app->id());
 
     // 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,
@@ skipping 21 matching lines @@
     sync_service->MergeDataAndStartSyncing(
         syncer::APPS,
         syncer::SyncDataList(),
         scoped_ptr<syncer::SyncChangeProcessor>(
             new syncer::SyncChangeProcessorWrapperForTest(
                 &mock_sync_processor_)),
         scoped_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock()));
   }
 
-  scoped_ptr<AppSyncData> GetFirstSyncChangeForApp(const std::string& id) {
+  scoped_ptr<AppSyncData> GetLastSyncChangeForApp(const std::string& id) {
     scoped_ptr<AppSyncData> sync_data;
     for (syncer::SyncChangeList::iterator it =
              mock_sync_processor_.changes().begin();
          it != mock_sync_processor_.changes().end(); ++it) {
-      sync_data.reset(new AppSyncData(*it));
-      if (sync_data->id() == id)
-        return sync_data.Pass();
+      scoped_ptr<AppSyncData> data(new AppSyncData(*it));
+      if (data->id() == id)
+        sync_data.reset(data.release());
     }
 
-    return scoped_ptr<AppSyncData>();
+    return sync_data.Pass();
   }
 
   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());
   }
 
@@ skipping 93 matching lines @@
   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) {
+  InitSyncService();
+
   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.
+
+  VerifyEphemeralApp(app_id);
+  CloseAppWaitForUnload(app_id);
+  VerifyInactiveEphemeralApp(app_id);
 
   // Update to version 2 of the app.
+  app_v1 = NULL;  // The extension object will be destroyed during update.
   InstallObserver installed_observer(profile());
   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 set.
   ASSERT_TRUE(app_v2);
   EXPECT_GT(app_v2->version()->CompareTo(app_original_version), 0);
-  EXPECT_TRUE(extensions::util::IsEphemeralApp(app_v2->id(), profile()));
+  VerifyEphemeralApp(app_id);
 
   // 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 = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
@@ skipping 160 matching lines @@
       ExtensionSystem::Get(profile())->extension_service();
   service->BlacklistExtensionForTest(app->id());
   ASSERT_TRUE(
       ExtensionRegistry::Get(profile())->blacklisted_extensions().Contains(
           app->id()));
 
   // 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());
+  scoped_ptr<AppSyncData> sync_change = GetLastSyncChangeForApp(app->id());
   VerifySyncChange(sync_change.get(), false);
 }
 
 // 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 = InstallAndLaunchEphemeralApp(kNotificationsTestApp);
@@ skipping 135 matching lines @@
 
   // 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);
 }