Ephemeral apps should not trigger Chrome background mode

chrome/browser/background/background_application_list_model_unittest.cc

 // Copyright (c) 2012 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.
 
 // TODO(rickcam): Bug 73183: Add unit tests for image loading
 
 #include <cstdlib>
 #include <set>
 
 #include "chrome/browser/background/background_application_list_model.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_types.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // This value is used to seed the PRNG at the beginning of a sequence of
 // operations to produce a repeatable sequence.
@@ skipping 115 matching lines @@
 
 void RemoveBackgroundPermission(ExtensionService* service,
                                 Extension* extension) {
   if (!BackgroundApplicationListModel::IsBackgroundApp(*extension,
                                                        service->profile())) {
     return;
   }
   extensions::PermissionsUpdater(service->profile()).RemovePermissions(
       extension, extension->permissions_data()->active_permissions().get());
 }
+
+void AddEphemeralApp(const Extension* extension, ExtensionService* service) {
+  extensions::ExtensionPrefs* prefs =
+      extensions::ExtensionPrefs::Get(service->profile());
+  ASSERT_TRUE(prefs);
+  prefs->OnExtensionInstalled(extension,
+                              extensions::Extension::ENABLED,
+                              syncer::StringOrdinal(),
+                              extensions::kInstallFlagIsEphemeral,
+                              std::string());
+
+  service->AddExtension(extension);
+}
+
 }  // namespace
 
 // Crashes on Mac tryslaves.
 // http://crbug.com/165458
 #if defined(OS_MACOSX) || defined(OS_LINUX)
 #define MAYBE_ExplicitTest DISABLED_ExplicitTest
 #else
 #define MAYBE_ExplicitTest ExplicitTest
 #endif
 // With minimal test logic, verifies behavior over an explicit set of
@@ skipping 140 matching lines @@
       bgapp2->id(), ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL);
   ASSERT_EQ(1U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
   ASSERT_TRUE(IsBackgroundApp(*bgapp3.get()));
   service->UninstallExtension(
       bgapp3->id(), ExtensionService::UNINSTALL_REASON_FOR_TESTING, NULL);
   ASSERT_EQ(0U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
 }
 
+// Verifies that an ephemeral app cannot trigger background mode.
+TEST_F(BackgroundApplicationListModelTest, EphemeralAppTest) {
+  InitializeAndLoadEmptyExtensionService();
+  ExtensionService* service = extensions::ExtensionSystem::Get(profile_.get())->
+      extension_service();
+  ASSERT_TRUE(service);
+  ASSERT_TRUE(service->is_ready());
+  ASSERT_TRUE(service->extensions());
+  ASSERT_TRUE(service->extensions()->is_empty());
+  scoped_ptr<BackgroundApplicationListModel> model(
+      new BackgroundApplicationListModel(profile_.get()));
+  ASSERT_EQ(0U, model->size());
 
+  scoped_refptr<Extension> installed =
+      CreateExtensionBase("installed", false, PUSH_MESSAGING_PERMISSION);
+  scoped_refptr<Extension> ephemeral =
+      CreateExtensionBase("ephemeral", false, PUSH_MESSAGING_PERMISSION);
+  scoped_refptr<Extension> background = CreateExtension("background", true);
+
+  // Installed app with push messaging permissions can trigger background mode.
+  ASSERT_TRUE(IsBackgroundApp(*installed.get()));
+  service->AddExtension(installed.get());
+  ASSERT_EQ(1U, service->extensions()->size());
+  ASSERT_EQ(1U, model->size());
+  // An ephemeral app with push messaging permissions should not trigger
+  // background mode.
+  AddEphemeralApp(ephemeral.get(), service);
+  ASSERT_FALSE(IsBackgroundApp(*ephemeral.get()));
+  ASSERT_EQ(2U, service->extensions()->size());
+  ASSERT_EQ(1U, model->size());
+  // An ephemeral app with the background permission should not trigger
+  // background mode.
+  AddEphemeralApp(background.get(), service);
+  ASSERT_FALSE(IsBackgroundApp(*background.get()));
+  ASSERT_EQ(3U, service->extensions()->size());
+  ASSERT_EQ(1U, model->size());
+
+  // If the ephemeral app becomes promoted to an installed app, it can now
+  // trigger background mode.
+  service->PromoteEphemeralApp(ephemeral.get(), false /*from sync*/);

[Andrew T Wilson (Slow), 2014/07/23 13:34:32]

Ideally, we'd also have a BackgroundModeManagerTest for this case (bubble is
displayed when ephemeral app is promoted). Can you add this?

+  ASSERT_TRUE(IsBackgroundApp(*ephemeral.get()));
+  ASSERT_EQ(3U, service->extensions()->size());
+  ASSERT_EQ(2U, model->size());
+}
 
 // With minimal test logic, verifies behavior with dynamic permissions.
 TEST_F(BackgroundApplicationListModelTest, AddRemovePermissionsTest) {
   InitializeAndLoadEmptyExtensionService();
   ExtensionService* service = extensions::ExtensionSystem::Get(profile_.get())->
       extension_service();
   ASSERT_TRUE(service);
   ASSERT_TRUE(service->is_ready());
   ASSERT_TRUE(service->extensions());
   ASSERT_TRUE(service->extensions()->is_empty());
@@ skipping 173 matching lines @@
         break;
       case 2:
         TogglePermission(service, &extensions, model.get(), &expected, &count);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }