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/saved_files_service.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 259 matching lines @@
 
     CloseApp(app->id());
     return result;
   }
 
   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());
+  }
+
+  // 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()));
 
@@ skipping 27 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 47 matching lines @@
   CloseApp(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());
 }
 
 // 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);
+  InitSyncService();
+
+  const Extension* app_v1 = InstallAndLaunchEphemeralApp(kMessagingReceiverApp);
   ASSERT_TRUE(app_v1);
   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);
+  CloseApp(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 enabled.
   ASSERT_TRUE(app_v2);
-  EXPECT_TRUE(app_v2->version()->CompareTo(app_original_version) > 0);
-  EXPECT_TRUE(extensions::util::IsEphemeralApp(app_v2->id(), profile()));
+  EXPECT_GT(app_v2->version()->CompareTo(app_original_version), 0);
+  VerifyEphemeralApp(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);
   ASSERT_TRUE(app);
 
   // Disable notifications for this app.
   DesktopNotificationService* notification_service =
@@ skipping 88 matching lines @@
 }
 
 // Checks the process of installing and then promoting an ephemeral app.
 IN_PROC_BROWSER_TEST_F(EphemeralAppBrowserTest, PromoteEphemeralApp) {
   InitSyncService();
 
   const Extension* app = InstallEphemeralApp(kNotificationsTestApp);
   ASSERT_TRUE(app);
 
   // Ephemeral apps should not be synced.
-  scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
+  scoped_ptr<AppSyncData> sync_change = GetLastSyncChangeForApp(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());
+  sync_change = GetLastSyncChangeForApp(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(kNotificationsTestApp);
   ASSERT_TRUE(app);
 
   // 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));
 
   // Promote to a regular installed app. It should be enabled.
   PromoteEphemeralApp(app);
   VerifyPromotedApp(app->id(), ExtensionRegistry::ENABLED);
   EXPECT_FALSE(prefs->DidExtensionEscalatePermissions(app->id()));
 
-  scoped_ptr<AppSyncData> sync_change = GetFirstSyncChangeForApp(app->id());
+  scoped_ptr<AppSyncData> sync_change = GetLastSyncChangeForApp(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(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());
+  scoped_ptr<AppSyncData> sync_change = GetLastSyncChangeForApp(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(kNotificationsTestApp);
   ASSERT_TRUE(app);
   std::string app_id = app->id();
@@ skipping 90 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);
 }