| // 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 "base/message_loop/message_loop_proxy.h" |
| #include "chrome/browser/apps/ephemeral_app_launcher.h" |
| #include "chrome/browser/apps/ephemeral_app_service.h" |
| #include "chrome/browser/extensions/extension_install_checker.h" |
| #include "chrome/browser/extensions/extension_service.h" |
| #include "chrome/browser/extensions/install_tracker.h" |
| #include "chrome/browser/extensions/test_blacklist.h" |
| #include "chrome/browser/extensions/webstore_installer_test.h" |
| #include "chrome/browser/ui/browser_finder.h" |
| #include "chrome/browser/ui/tabs/tab_strip_model.h" |
| #include "chrome/common/chrome_switches.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/test/test_utils.h" |
| #include "extensions/browser/extension_prefs.h" |
| #include "extensions/browser/extension_registry.h" |
| #include "extensions/browser/extension_system.h" |
| #include "extensions/browser/extension_util.h" |
| #include "extensions/browser/management_policy.h" |
| #include "extensions/browser/process_manager.h" |
| #include "extensions/common/switches.h" |
| #include "extensions/test/extension_test_message_listener.h" |
| |
| using extensions::Extension; |
| using extensions::ExtensionPrefs; |
| using extensions::ExtensionRegistry; |
| using extensions::ExtensionSystem; |
| using extensions::InstallTracker; |
| namespace webstore_install = extensions::webstore_install; |
| |
| namespace { |
| |
| const char kWebstoreDomain[] = "cws.com"; |
| const char kAppDomain[] = "app.com"; |
| const char kNonAppDomain[] = "nonapp.com"; |
| const char kTestDataPath[] = "extensions/platform_apps/ephemeral_launcher"; |
| |
| const char kExtensionId[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeid"; |
| const char kExtensionTestPath[] = "extension"; |
| const char kLegacyAppId[] = "lnbochkobjfnhbnbljgfgokadhmbahcn"; |
| const char kLegacyAppTestPath[] = "legacy_app"; |
| const char kNonExistentId[] = "baaaaaaaaaaaaaaaaaaaaaaaaaaaadid"; |
| const char kDefaultAppId[] = "kbiancnbopdghkfedjhfdoegjadfjeal"; |
| const char kDefaultAppCrxFilename[] = "app.crx"; |
| const char kDefaultAppTestPath[] = "app"; |
| const char kAppWithPermissionsId[] = "mbfcnecjknjpipkfkoangpfnhhlpamki"; |
| const char kAppWithPermissionsFilename[] = "app_with_permissions.crx"; |
| const char kHostedAppId[] = "haaaaaaaaaaaaaaaaaaaaaaaaaaappid"; |
| const char kHostedAppLaunchUrl[] = "http://foo.bar.com"; |
| |
| class ExtensionInstallCheckerMock : public extensions::ExtensionInstallChecker { |
| public: |
| ExtensionInstallCheckerMock(Profile* profile, |
| const std::string& requirements_error) |
| : extensions::ExtensionInstallChecker(profile), |
| requirements_error_(requirements_error) {} |
| |
| ~ExtensionInstallCheckerMock() override {} |
| |
| private: |
| void CheckRequirements() override { |
| // Simulate an asynchronous operation. |
| base::MessageLoopProxy::current()->PostTask( |
| FROM_HERE, |
| base::Bind(&ExtensionInstallCheckerMock::RequirementsErrorCheckDone, |
| base::Unretained(this), |
| current_sequence_number())); |
| } |
| |
| void RequirementsErrorCheckDone(int sequence_number) { |
| std::vector<std::string> errors; |
| errors.push_back(requirements_error_); |
| OnRequirementsCheckDone(sequence_number, errors); |
| } |
| |
| std::string requirements_error_; |
| }; |
| |
| class EphemeralAppLauncherForTest : public EphemeralAppLauncher { |
| public: |
| EphemeralAppLauncherForTest(const std::string& id, |
| Profile* profile, |
| const LaunchCallback& callback) |
| : EphemeralAppLauncher(id, profile, NULL, callback), |
| install_initiated_(false), |
| install_prompt_created_(false) {} |
| |
| EphemeralAppLauncherForTest(const std::string& id, Profile* profile) |
| : EphemeralAppLauncher(id, profile, NULL, LaunchCallback()), |
| install_initiated_(false), |
| install_prompt_created_(false) {} |
| |
| bool install_initiated() const { return install_initiated_; } |
| bool install_prompt_created() const { return install_prompt_created_; } |
| |
| void set_requirements_error(const std::string& error) { |
| requirements_check_error_ = error; |
| } |
| |
| private: |
| // Override necessary functions for testing. |
| |
| scoped_ptr<extensions::ExtensionInstallChecker> CreateInstallChecker() |
| override { |
| if (requirements_check_error_.empty()) { |
| return EphemeralAppLauncher::CreateInstallChecker(); |
| } else { |
| return scoped_ptr<extensions::ExtensionInstallChecker>( |
| new ExtensionInstallCheckerMock(profile(), |
| requirements_check_error_)); |
| } |
| } |
| |
| scoped_ptr<ExtensionInstallPrompt> CreateInstallUI() override { |
| install_prompt_created_ = true; |
| return EphemeralAppLauncher::CreateInstallUI(); |
| } |
| |
| scoped_ptr<extensions::WebstoreInstaller::Approval> CreateApproval() |
| const override { |
| install_initiated_ = true; |
| return EphemeralAppLauncher::CreateApproval(); |
| } |
| |
| private: |
| ~EphemeralAppLauncherForTest() override {} |
| friend class base::RefCountedThreadSafe<EphemeralAppLauncherForTest>; |
| |
| mutable bool install_initiated_; |
| std::string requirements_check_error_; |
| bool install_prompt_created_; |
| }; |
| |
| class LaunchObserver { |
| public: |
| LaunchObserver() |
| : done_(false), |
| waiting_(false), |
| result_(webstore_install::OTHER_ERROR) {} |
| |
| webstore_install::Result result() const { return result_; } |
| const std::string& error() const { return error_; } |
| |
| void OnLaunchCallback(webstore_install::Result result, |
| const std::string& error) { |
| result_ = result; |
| error_ = error; |
| done_ = true; |
| if (waiting_) { |
| waiting_ = false; |
| base::MessageLoopForUI::current()->Quit(); |
| } |
| } |
| |
| void Wait() { |
| if (done_) |
| return; |
| |
| waiting_ = true; |
| content::RunMessageLoop(); |
| } |
| |
| private: |
| bool done_; |
| bool waiting_; |
| webstore_install::Result result_; |
| std::string error_; |
| }; |
| |
| class ManagementPolicyMock : public extensions::ManagementPolicy::Provider { |
| public: |
| ManagementPolicyMock() {} |
| |
| std::string GetDebugPolicyProviderName() const override { |
| return "ManagementPolicyMock"; |
| } |
| |
| bool UserMayLoad(const Extension* extension, |
| base::string16* error) const override { |
| return false; |
| } |
| }; |
| |
| } // namespace |
| |
| class EphemeralAppLauncherTest : public WebstoreInstallerTest { |
| public: |
| EphemeralAppLauncherTest() |
| : WebstoreInstallerTest(kWebstoreDomain, |
| kTestDataPath, |
| kDefaultAppCrxFilename, |
| kAppDomain, |
| kNonAppDomain) {} |
| |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| WebstoreInstallerTest::SetUpCommandLine(command_line); |
| |
| // Make event pages get suspended immediately. |
| extensions::ProcessManager::SetEventPageIdleTimeForTesting(1); |
| extensions::ProcessManager::SetEventPageSuspendingTimeForTesting(1); |
| |
| // Enable ephemeral apps flag. |
| command_line->AppendSwitch(switches::kEnableEphemeralApps); |
| } |
| |
| void SetUpOnMainThread() override { |
| WebstoreInstallerTest::SetUpOnMainThread(); |
| |
| // Disable ephemeral apps immediately after they stop running in tests. |
| EphemeralAppService::Get(profile())->set_disable_delay_for_test(0); |
| } |
| |
| base::FilePath GetTestPath(const char* test_name) { |
| return test_data_dir_.AppendASCII("platform_apps/ephemeral_launcher") |
| .AppendASCII(test_name); |
| } |
| |
| const Extension* GetInstalledExtension(const std::string& id) { |
| return ExtensionRegistry::Get(profile()) |
| ->GetExtensionById(id, ExtensionRegistry::EVERYTHING); |
| } |
| |
| void SetCrxFilename(const std::string& filename) { |
| GURL crx_url = GenerateTestServerUrl(kWebstoreDomain, filename); |
| base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| switches::kAppsGalleryUpdateURL, crx_url.spec()); |
| } |
| |
| void StartLauncherAndCheckResult(EphemeralAppLauncherForTest* launcher, |
| webstore_install::Result expected_result, |
| bool expect_install_initiated) { |
| ExtensionTestMessageListener launched_listener("launched", false); |
| LaunchObserver launch_observer; |
| |
| launcher->launch_callback_ = base::Bind(&LaunchObserver::OnLaunchCallback, |
| base::Unretained(&launch_observer)); |
| launcher->Start(); |
| launch_observer.Wait(); |
| |
| // Verify the launch result. |
| EXPECT_EQ(expected_result, launch_observer.result()); |
| EXPECT_EQ(expect_install_initiated, launcher->install_initiated()); |
| |
| // Verify that the app was actually launched if the launcher succeeded. |
| if (launch_observer.result() == webstore_install::SUCCESS) |
| EXPECT_TRUE(launched_listener.WaitUntilSatisfied()); |
| else |
| EXPECT_FALSE(launched_listener.was_satisfied()); |
| |
| // Check the reference count to ensure the launcher instance will not be |
| // leaked. |
| EXPECT_TRUE(launcher->HasOneRef()); |
| } |
| |
| void RunLaunchTest(const std::string& id, |
| webstore_install::Result expected_result, |
| bool expect_install_initiated) { |
| InstallTracker* tracker = InstallTracker::Get(profile()); |
| ASSERT_TRUE(tracker); |
| bool was_install_active = !!tracker->GetActiveInstall(id); |
| |
| scoped_refptr<EphemeralAppLauncherForTest> launcher( |
| new EphemeralAppLauncherForTest(id, profile())); |
| StartLauncherAndCheckResult( |
| launcher.get(), expected_result, expect_install_initiated); |
| |
| // Verify that the install was deregistered from the InstallTracker. |
| EXPECT_EQ(was_install_active, !!tracker->GetActiveInstall(id)); |
| } |
| |
| void ValidateAppInstalledEphemerally(const std::string& id) { |
| EXPECT_TRUE(GetInstalledExtension(id)); |
| EXPECT_TRUE(extensions::util::IsEphemeralApp(id, profile())); |
| } |
| |
| const Extension* InstallAndDisableApp( |
| const char* test_path, |
| Extension::DisableReason disable_reason) { |
| const Extension* app = InstallExtension(GetTestPath(test_path), 1); |
| EXPECT_TRUE(app); |
| if (!app) |
| return NULL; |
| |
| ExtensionService* service = |
| ExtensionSystem::Get(profile())->extension_service(); |
| service->DisableExtension(app->id(), disable_reason); |
| |
| if (disable_reason == Extension::DISABLE_PERMISSIONS_INCREASE) { |
| // When an extension is disabled due to a permissions increase, this |
| // flag needs to be set too, for some reason. |
| ExtensionPrefs::Get(profile()) |
| ->SetDidExtensionEscalatePermissions(app, true); |
| } |
| |
| EXPECT_TRUE( |
| ExtensionRegistry::Get(profile())->disabled_extensions().Contains( |
| app->id())); |
| return app; |
| } |
| }; |
| |
| class EphemeralAppLauncherTestDisabled : public EphemeralAppLauncherTest { |
| public: |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| // Skip EphemeralAppLauncherTest as it enables the feature. |
| WebstoreInstallerTest::SetUpCommandLine(command_line); |
| } |
| }; |
| |
| // Verifies that an ephemeral app will not be installed and launched if the |
| // feature is disabled. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTestDisabled, FeatureDisabled) { |
| RunLaunchTest( |
| kDefaultAppCrxFilename, webstore_install::LAUNCH_FEATURE_DISABLED, false); |
| EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); |
| } |
| |
| // Verifies that an app with no permission warnings will be installed |
| // ephemerally and launched without prompting the user. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, |
| LaunchAppWithNoPermissionWarnings) { |
| content::WindowedNotificationObserver unloaded_signal( |
| extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED, |
| content::Source<Profile>(profile())); |
| |
| scoped_refptr<EphemeralAppLauncherForTest> launcher( |
| new EphemeralAppLauncherForTest(kDefaultAppId, profile())); |
| StartLauncherAndCheckResult(launcher.get(), webstore_install::SUCCESS, true); |
| ValidateAppInstalledEphemerally(kDefaultAppId); |
| |
| // Apps with no permission warnings should not result in a prompt. |
| EXPECT_FALSE(launcher->install_prompt_created()); |
| |
| // Ephemeral apps are unloaded after they stop running. |
| unloaded_signal.Wait(); |
| |
| // After an app has been installed ephemerally, it can be launched again |
| // without installing from the web store. |
| RunLaunchTest(kDefaultAppId, webstore_install::SUCCESS, false); |
| } |
| |
| // Verifies that an app with permission warnings will be installed |
| // ephemerally and launched if accepted by the user. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, |
| LaunchAppWithPermissionsWarnings) { |
| SetCrxFilename(kAppWithPermissionsFilename); |
| AutoAcceptInstall(); |
| |
| scoped_refptr<EphemeralAppLauncherForTest> launcher( |
| new EphemeralAppLauncherForTest(kAppWithPermissionsId, profile())); |
| StartLauncherAndCheckResult(launcher.get(), webstore_install::SUCCESS, true); |
| ValidateAppInstalledEphemerally(kAppWithPermissionsId); |
| EXPECT_TRUE(launcher->install_prompt_created()); |
| } |
| |
| // Verifies that an app with permission warnings will not be installed |
| // ephemerally if cancelled by the user. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, |
| CancelInstallAppWithPermissionWarnings) { |
| SetCrxFilename(kAppWithPermissionsFilename); |
| AutoCancelInstall(); |
| |
| scoped_refptr<EphemeralAppLauncherForTest> launcher( |
| new EphemeralAppLauncherForTest(kAppWithPermissionsId, profile())); |
| StartLauncherAndCheckResult( |
| launcher.get(), webstore_install::USER_CANCELLED, false); |
| EXPECT_FALSE(GetInstalledExtension(kAppWithPermissionsId)); |
| EXPECT_TRUE(launcher->install_prompt_created()); |
| } |
| |
| // Verifies that an extension will not be installed ephemerally. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, InstallExtension) { |
| RunLaunchTest( |
| kExtensionId, webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE, false); |
| EXPECT_FALSE(GetInstalledExtension(kExtensionId)); |
| } |
| |
| // Verifies that an already installed extension will not be launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchExtension) { |
| const Extension* extension = |
| InstallExtension(GetTestPath(kExtensionTestPath), 1); |
| ASSERT_TRUE(extension); |
| RunLaunchTest(extension->id(), |
| webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE, |
| false); |
| } |
| |
| // Verifies that a legacy packaged app will not be installed ephemerally. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, InstallLegacyApp) { |
| RunLaunchTest( |
| kLegacyAppId, webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE, false); |
| EXPECT_FALSE(GetInstalledExtension(kLegacyAppId)); |
| } |
| |
| // Verifies that a legacy packaged app that is already installed can be |
| // launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchLegacyApp) { |
| const Extension* extension = |
| InstallExtension(GetTestPath(kLegacyAppTestPath), 1); |
| ASSERT_TRUE(extension); |
| RunLaunchTest(extension->id(), webstore_install::SUCCESS, false); |
| } |
| |
| // Verifies that a hosted app is not installed. Launch succeeds because we |
| // navigate to its launch url. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchHostedApp) { |
| LaunchObserver launch_observer; |
| |
| scoped_refptr<EphemeralAppLauncherForTest> launcher( |
| new EphemeralAppLauncherForTest( |
| kHostedAppId, |
| profile(), |
| base::Bind(&LaunchObserver::OnLaunchCallback, |
| base::Unretained(&launch_observer)))); |
| launcher->Start(); |
| launch_observer.Wait(); |
| |
| EXPECT_EQ(webstore_install::SUCCESS, launch_observer.result()); |
| EXPECT_FALSE(launcher->install_initiated()); |
| EXPECT_FALSE(GetInstalledExtension(kHostedAppId)); |
| |
| // Verify that a navigation to the launch url was attempted. |
| Browser* browser = |
| FindBrowserWithProfile(profile(), chrome::GetActiveDesktop()); |
| ASSERT_TRUE(browser); |
| content::WebContents* web_contents = |
| browser->tab_strip_model()->GetActiveWebContents(); |
| ASSERT_TRUE(web_contents); |
| EXPECT_EQ(GURL(kHostedAppLaunchUrl), web_contents->GetVisibleURL()); |
| } |
| |
| // Verifies that the EphemeralAppLauncher handles non-existent extension ids. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, NonExistentExtensionId) { |
| RunLaunchTest( |
| kNonExistentId, webstore_install::WEBSTORE_REQUEST_ERROR, false); |
| EXPECT_FALSE(GetInstalledExtension(kNonExistentId)); |
| } |
| |
| // Verifies that an app blocked by management policy is not installed |
| // ephemerally. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, BlockedByPolicy) { |
| // Register a provider that blocks the installation of all apps. |
| ManagementPolicyMock policy; |
| ExtensionSystem::Get(profile())->management_policy()->RegisterProvider( |
| &policy); |
| |
| RunLaunchTest(kDefaultAppId, webstore_install::BLOCKED_BY_POLICY, false); |
| EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); |
| } |
| |
| // Verifies that an app blacklisted for malware is not installed ephemerally. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, BlacklistedForMalware) { |
| // Mock a BLACKLISTED_MALWARE return status. |
| extensions::TestBlacklist blacklist_tester( |
| extensions::Blacklist::Get(profile())); |
| blacklist_tester.SetBlacklistState( |
| kDefaultAppId, extensions::BLACKLISTED_MALWARE, false); |
| |
| RunLaunchTest(kDefaultAppId, webstore_install::BLACKLISTED, false); |
| EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); |
| } |
| |
| // Verifies that an app with unknown blacklist status is installed ephemerally |
| // and launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, BlacklistStateUnknown) { |
| // Mock a BLACKLISTED_MALWARE return status. |
| extensions::TestBlacklist blacklist_tester( |
| extensions::Blacklist::Get(profile())); |
| blacklist_tester.SetBlacklistState( |
| kDefaultAppId, extensions::BLACKLISTED_UNKNOWN, false); |
| |
| RunLaunchTest(kDefaultAppId, webstore_install::SUCCESS, true); |
| ValidateAppInstalledEphemerally(kDefaultAppId); |
| } |
| |
| // Verifies that an app with unsupported requirements is not installed |
| // ephemerally. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, UnsupportedRequirements) { |
| scoped_refptr<EphemeralAppLauncherForTest> launcher( |
| new EphemeralAppLauncherForTest(kDefaultAppId, profile())); |
| launcher->set_requirements_error("App has unsupported requirements"); |
| |
| StartLauncherAndCheckResult( |
| launcher.get(), webstore_install::REQUIREMENT_VIOLATIONS, false); |
| EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); |
| } |
| |
| // Verifies that an app disabled due to permissions increase can be enabled |
| // and launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, EnableAndLaunchApp) { |
| const Extension* app = InstallAndDisableApp( |
| kDefaultAppTestPath, Extension::DISABLE_PERMISSIONS_INCREASE); |
| ASSERT_TRUE(app); |
| |
| AutoAcceptInstall(); |
| RunLaunchTest(app->id(), webstore_install::SUCCESS, false); |
| } |
| |
| // Verifies that if the user cancels the enable flow, the app will not be |
| // enabled and launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, EnableCancelled) { |
| const Extension* app = InstallAndDisableApp( |
| kDefaultAppTestPath, Extension::DISABLE_PERMISSIONS_INCREASE); |
| ASSERT_TRUE(app); |
| |
| AutoCancelInstall(); |
| RunLaunchTest(app->id(), webstore_install::USER_CANCELLED, false); |
| } |
| |
| // Verifies that an installed app that had been blocked by policy cannot be |
| // launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchAppBlockedByPolicy) { |
| const Extension* app = InstallExtension(GetTestPath(kDefaultAppTestPath), 1); |
| ASSERT_TRUE(app); |
| |
| // Simulate blocking of the app after it has been installed. |
| ManagementPolicyMock policy; |
| ExtensionSystem::Get(profile())->management_policy()->RegisterProvider( |
| &policy); |
| ExtensionSystem::Get(profile())->extension_service()->CheckManagementPolicy(); |
| |
| RunLaunchTest(app->id(), webstore_install::BLOCKED_BY_POLICY, false); |
| } |
| |
| // Verifies that an installed blacklisted app cannot be launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchBlacklistedApp) { |
| const Extension* app = InstallExtension(GetTestPath(kDefaultAppTestPath), 1); |
| ASSERT_TRUE(app); |
| |
| ExtensionService* service = |
| ExtensionSystem::Get(profile())->extension_service(); |
| service->BlacklistExtensionForTest(app->id()); |
| ASSERT_TRUE( |
| ExtensionRegistry::Get(profile())->blacklisted_extensions().Contains( |
| app->id())); |
| |
| RunLaunchTest(app->id(), webstore_install::BLACKLISTED, false); |
| } |
| |
| // Verifies that an installed app with unsupported requirements cannot be |
| // launched. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, |
| LaunchAppWithUnsupportedRequirements) { |
| const Extension* app = InstallAndDisableApp( |
| kDefaultAppTestPath, Extension::DISABLE_UNSUPPORTED_REQUIREMENT); |
| ASSERT_TRUE(app); |
| |
| RunLaunchTest(app->id(), webstore_install::REQUIREMENT_VIOLATIONS, false); |
| } |
| |
| // Verifies that a launch will fail if the app is currently being installed. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, InstallInProgress) { |
| extensions::ActiveInstallData install_data(kDefaultAppId); |
| InstallTracker::Get(profile())->AddActiveInstall(install_data); |
| |
| RunLaunchTest(kDefaultAppId, webstore_install::INSTALL_IN_PROGRESS, false); |
| } |
| |
| // Verifies that a launch will fail if a duplicate launch is in progress. |
| IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, DuplicateLaunchInProgress) { |
| extensions::ActiveInstallData install_data(kDefaultAppId); |
| install_data.is_ephemeral = true; |
| InstallTracker::Get(profile())->AddActiveInstall(install_data); |
| |
| RunLaunchTest(kDefaultAppId, webstore_install::LAUNCH_IN_PROGRESS, false); |
| } |