| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/thread_task_runner_handle.h" | |
| 6 #include "chrome/browser/apps/ephemeral_app_launcher.h" | |
| 7 #include "chrome/browser/apps/ephemeral_app_service.h" | |
| 8 #include "chrome/browser/extensions/extension_install_checker.h" | |
| 9 #include "chrome/browser/extensions/extension_service.h" | |
| 10 #include "chrome/browser/extensions/install_tracker.h" | |
| 11 #include "chrome/browser/extensions/test_blacklist.h" | |
| 12 #include "chrome/browser/extensions/webstore_installer_test.h" | |
| 13 #include "chrome/browser/ui/browser_finder.h" | |
| 14 #include "chrome/browser/ui/tabs/tab_strip_model.h" | |
| 15 #include "chrome/common/chrome_switches.h" | |
| 16 #include "content/public/browser/web_contents.h" | |
| 17 #include "content/public/test/test_utils.h" | |
| 18 #include "extensions/browser/extension_prefs.h" | |
| 19 #include "extensions/browser/extension_registry.h" | |
| 20 #include "extensions/browser/extension_system.h" | |
| 21 #include "extensions/browser/extension_util.h" | |
| 22 #include "extensions/browser/management_policy.h" | |
| 23 #include "extensions/browser/process_manager.h" | |
| 24 #include "extensions/browser/test_extension_registry_observer.h" | |
| 25 #include "extensions/test/extension_test_message_listener.h" | |
| 26 | |
| 27 using extensions::Extension; | |
| 28 using extensions::ExtensionPrefs; | |
| 29 using extensions::ExtensionRegistry; | |
| 30 using extensions::ExtensionSystem; | |
| 31 using extensions::InstallTracker; | |
| 32 namespace webstore_install = extensions::webstore_install; | |
| 33 | |
| 34 namespace { | |
| 35 | |
| 36 const char kWebstoreDomain[] = "cws.com"; | |
| 37 const char kAppDomain[] = "app.com"; | |
| 38 const char kNonAppDomain[] = "nonapp.com"; | |
| 39 const char kTestDataPath[] = "extensions/platform_apps/ephemeral_launcher"; | |
| 40 | |
| 41 const char kExtensionId[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeid"; | |
| 42 const char kExtensionTestPath[] = "extension"; | |
| 43 const char kLegacyAppId[] = "lnbochkobjfnhbnbljgfgokadhmbahcn"; | |
| 44 const char kLegacyAppTestPath[] = "legacy_app"; | |
| 45 const char kNonExistentId[] = "baaaaaaaaaaaaaaaaaaaaaaaaaaaadid"; | |
| 46 const char kDefaultAppId[] = "kbiancnbopdghkfedjhfdoegjadfjeal"; | |
| 47 const char kDefaultAppCrxFilename[] = "app.crx"; | |
| 48 const char kDefaultAppTestPath[] = "app"; | |
| 49 const char kAppWithPermissionsId[] = "mbfcnecjknjpipkfkoangpfnhhlpamki"; | |
| 50 const char kAppWithPermissionsFilename[] = "app_with_permissions.crx"; | |
| 51 const char kHostedAppId[] = "haaaaaaaaaaaaaaaaaaaaaaaaaaappid"; | |
| 52 const char kHostedAppLaunchUrl[] = "http://foo.bar.com"; | |
| 53 | |
| 54 class ExtensionInstallCheckerMock : public extensions::ExtensionInstallChecker { | |
| 55 public: | |
| 56 ExtensionInstallCheckerMock(Profile* profile, | |
| 57 const std::string& requirements_error) | |
| 58 : extensions::ExtensionInstallChecker(profile), | |
| 59 requirements_error_(requirements_error) {} | |
| 60 | |
| 61 ~ExtensionInstallCheckerMock() override {} | |
| 62 | |
| 63 private: | |
| 64 void CheckRequirements() override { | |
| 65 // Simulate an asynchronous operation. | |
| 66 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
| 67 FROM_HERE, | |
| 68 base::Bind(&ExtensionInstallCheckerMock::RequirementsErrorCheckDone, | |
| 69 base::Unretained(this), current_sequence_number())); | |
| 70 } | |
| 71 | |
| 72 void RequirementsErrorCheckDone(int sequence_number) { | |
| 73 std::vector<std::string> errors; | |
| 74 errors.push_back(requirements_error_); | |
| 75 OnRequirementsCheckDone(sequence_number, errors); | |
| 76 } | |
| 77 | |
| 78 std::string requirements_error_; | |
| 79 }; | |
| 80 | |
| 81 class EphemeralAppLauncherForTest : public EphemeralAppLauncher { | |
| 82 public: | |
| 83 EphemeralAppLauncherForTest(const std::string& id, | |
| 84 Profile* profile, | |
| 85 const LaunchCallback& callback) | |
| 86 : EphemeralAppLauncher(id, profile, NULL, callback), | |
| 87 install_initiated_(false), | |
| 88 install_prompt_created_(false) {} | |
| 89 | |
| 90 EphemeralAppLauncherForTest(const std::string& id, Profile* profile) | |
| 91 : EphemeralAppLauncher(id, profile, NULL, LaunchCallback()), | |
| 92 install_initiated_(false), | |
| 93 install_prompt_created_(false) {} | |
| 94 | |
| 95 bool install_initiated() const { return install_initiated_; } | |
| 96 bool install_prompt_created() const { return install_prompt_created_; } | |
| 97 | |
| 98 void set_requirements_error(const std::string& error) { | |
| 99 requirements_check_error_ = error; | |
| 100 } | |
| 101 | |
| 102 private: | |
| 103 // Override necessary functions for testing. | |
| 104 | |
| 105 scoped_ptr<extensions::ExtensionInstallChecker> CreateInstallChecker() | |
| 106 override { | |
| 107 if (requirements_check_error_.empty()) { | |
| 108 return EphemeralAppLauncher::CreateInstallChecker(); | |
| 109 } else { | |
| 110 return scoped_ptr<extensions::ExtensionInstallChecker>( | |
| 111 new ExtensionInstallCheckerMock(profile(), | |
| 112 requirements_check_error_)); | |
| 113 } | |
| 114 } | |
| 115 | |
| 116 scoped_ptr<ExtensionInstallPrompt> CreateInstallUI() override { | |
| 117 install_prompt_created_ = true; | |
| 118 return EphemeralAppLauncher::CreateInstallUI(); | |
| 119 } | |
| 120 | |
| 121 scoped_ptr<extensions::WebstoreInstaller::Approval> CreateApproval() | |
| 122 const override { | |
| 123 install_initiated_ = true; | |
| 124 return EphemeralAppLauncher::CreateApproval(); | |
| 125 } | |
| 126 | |
| 127 private: | |
| 128 ~EphemeralAppLauncherForTest() override {} | |
| 129 friend class base::RefCountedThreadSafe<EphemeralAppLauncherForTest>; | |
| 130 | |
| 131 mutable bool install_initiated_; | |
| 132 std::string requirements_check_error_; | |
| 133 bool install_prompt_created_; | |
| 134 }; | |
| 135 | |
| 136 class LaunchObserver { | |
| 137 public: | |
| 138 LaunchObserver() | |
| 139 : done_(false), | |
| 140 waiting_(false), | |
| 141 result_(webstore_install::OTHER_ERROR) {} | |
| 142 | |
| 143 webstore_install::Result result() const { return result_; } | |
| 144 const std::string& error() const { return error_; } | |
| 145 | |
| 146 void OnLaunchCallback(webstore_install::Result result, | |
| 147 const std::string& error) { | |
| 148 result_ = result; | |
| 149 error_ = error; | |
| 150 done_ = true; | |
| 151 if (waiting_) { | |
| 152 waiting_ = false; | |
| 153 base::MessageLoopForUI::current()->Quit(); | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 void Wait() { | |
| 158 if (done_) | |
| 159 return; | |
| 160 | |
| 161 waiting_ = true; | |
| 162 content::RunMessageLoop(); | |
| 163 } | |
| 164 | |
| 165 private: | |
| 166 bool done_; | |
| 167 bool waiting_; | |
| 168 webstore_install::Result result_; | |
| 169 std::string error_; | |
| 170 }; | |
| 171 | |
| 172 class ManagementPolicyMock : public extensions::ManagementPolicy::Provider { | |
| 173 public: | |
| 174 ManagementPolicyMock() {} | |
| 175 | |
| 176 std::string GetDebugPolicyProviderName() const override { | |
| 177 return "ManagementPolicyMock"; | |
| 178 } | |
| 179 | |
| 180 bool UserMayLoad(const Extension* extension, | |
| 181 base::string16* error) const override { | |
| 182 return false; | |
| 183 } | |
| 184 }; | |
| 185 | |
| 186 } // namespace | |
| 187 | |
| 188 class EphemeralAppLauncherTest : public WebstoreInstallerTest { | |
| 189 public: | |
| 190 EphemeralAppLauncherTest() | |
| 191 : WebstoreInstallerTest(kWebstoreDomain, | |
| 192 kTestDataPath, | |
| 193 kDefaultAppCrxFilename, | |
| 194 kAppDomain, | |
| 195 kNonAppDomain) {} | |
| 196 | |
| 197 void SetUpCommandLine(base::CommandLine* command_line) override { | |
| 198 WebstoreInstallerTest::SetUpCommandLine(command_line); | |
| 199 | |
| 200 // Make event pages get suspended immediately. | |
| 201 extensions::ProcessManager::SetEventPageIdleTimeForTesting(1); | |
| 202 extensions::ProcessManager::SetEventPageSuspendingTimeForTesting(1); | |
| 203 | |
| 204 // Enable ephemeral apps flag. | |
| 205 command_line->AppendSwitch(switches::kEnableEphemeralAppsInWebstore); | |
| 206 } | |
| 207 | |
| 208 void SetUpOnMainThread() override { | |
| 209 WebstoreInstallerTest::SetUpOnMainThread(); | |
| 210 | |
| 211 // Disable ephemeral apps immediately after they stop running in tests. | |
| 212 EphemeralAppService::Get(profile())->set_disable_delay_for_test(0); | |
| 213 } | |
| 214 | |
| 215 base::FilePath GetTestPath(const char* test_name) { | |
| 216 return test_data_dir_.AppendASCII("platform_apps/ephemeral_launcher") | |
| 217 .AppendASCII(test_name); | |
| 218 } | |
| 219 | |
| 220 const Extension* GetInstalledExtension(const std::string& id) { | |
| 221 return ExtensionRegistry::Get(profile()) | |
| 222 ->GetExtensionById(id, ExtensionRegistry::EVERYTHING); | |
| 223 } | |
| 224 | |
| 225 void SetCrxFilename(const std::string& filename) { | |
| 226 GURL crx_url = GenerateTestServerUrl(kWebstoreDomain, filename); | |
| 227 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | |
| 228 switches::kAppsGalleryUpdateURL, crx_url.spec()); | |
| 229 } | |
| 230 | |
| 231 void StartLauncherAndCheckResult(EphemeralAppLauncherForTest* launcher, | |
| 232 webstore_install::Result expected_result, | |
| 233 bool expect_install_initiated) { | |
| 234 ExtensionTestMessageListener launched_listener("launched", false); | |
| 235 LaunchObserver launch_observer; | |
| 236 | |
| 237 launcher->launch_callback_ = base::Bind(&LaunchObserver::OnLaunchCallback, | |
| 238 base::Unretained(&launch_observer)); | |
| 239 launcher->Start(); | |
| 240 launch_observer.Wait(); | |
| 241 | |
| 242 // Verify the launch result. | |
| 243 EXPECT_EQ(expected_result, launch_observer.result()); | |
| 244 EXPECT_EQ(expect_install_initiated, launcher->install_initiated()); | |
| 245 | |
| 246 // Verify that the app was actually launched if the launcher succeeded. | |
| 247 if (launch_observer.result() == webstore_install::SUCCESS) | |
| 248 EXPECT_TRUE(launched_listener.WaitUntilSatisfied()); | |
| 249 else | |
| 250 EXPECT_FALSE(launched_listener.was_satisfied()); | |
| 251 | |
| 252 // Check the reference count to ensure the launcher instance will not be | |
| 253 // leaked. | |
| 254 EXPECT_TRUE(launcher->HasOneRef()); | |
| 255 } | |
| 256 | |
| 257 void RunLaunchTest(const std::string& id, | |
| 258 webstore_install::Result expected_result, | |
| 259 bool expect_install_initiated) { | |
| 260 InstallTracker* tracker = InstallTracker::Get(profile()); | |
| 261 ASSERT_TRUE(tracker); | |
| 262 bool was_install_active = !!tracker->GetActiveInstall(id); | |
| 263 | |
| 264 scoped_refptr<EphemeralAppLauncherForTest> launcher( | |
| 265 new EphemeralAppLauncherForTest(id, profile())); | |
| 266 StartLauncherAndCheckResult( | |
| 267 launcher.get(), expected_result, expect_install_initiated); | |
| 268 | |
| 269 // Verify that the install was deregistered from the InstallTracker. | |
| 270 EXPECT_EQ(was_install_active, !!tracker->GetActiveInstall(id)); | |
| 271 } | |
| 272 | |
| 273 void ValidateAppInstalledEphemerally(const std::string& id) { | |
| 274 EXPECT_TRUE(GetInstalledExtension(id)); | |
| 275 EXPECT_TRUE(extensions::util::IsEphemeralApp(id, profile())); | |
| 276 } | |
| 277 | |
| 278 const Extension* InstallAndDisableApp( | |
| 279 const char* test_path, | |
| 280 Extension::DisableReason disable_reason) { | |
| 281 const Extension* app = InstallExtension(GetTestPath(test_path), 1); | |
| 282 EXPECT_TRUE(app); | |
| 283 if (!app) | |
| 284 return NULL; | |
| 285 | |
| 286 ExtensionService* service = | |
| 287 ExtensionSystem::Get(profile())->extension_service(); | |
| 288 service->DisableExtension(app->id(), disable_reason); | |
| 289 | |
| 290 EXPECT_TRUE( | |
| 291 ExtensionRegistry::Get(profile())->disabled_extensions().Contains( | |
| 292 app->id())); | |
| 293 return app; | |
| 294 } | |
| 295 }; | |
| 296 | |
| 297 class EphemeralAppLauncherTestDisabled : public EphemeralAppLauncherTest { | |
| 298 public: | |
| 299 void SetUpCommandLine(base::CommandLine* command_line) override { | |
| 300 // Skip EphemeralAppLauncherTest as it enables the feature. | |
| 301 WebstoreInstallerTest::SetUpCommandLine(command_line); | |
| 302 } | |
| 303 }; | |
| 304 | |
| 305 // Verifies that an ephemeral app will not be installed and launched if the | |
| 306 // feature is disabled. | |
| 307 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTestDisabled, FeatureDisabled) { | |
| 308 RunLaunchTest( | |
| 309 kDefaultAppCrxFilename, webstore_install::LAUNCH_FEATURE_DISABLED, false); | |
| 310 EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); | |
| 311 } | |
| 312 | |
| 313 // Verifies that an app with no permission warnings will be installed | |
| 314 // ephemerally and launched without prompting the user. | |
| 315 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, | |
| 316 LaunchAppWithNoPermissionWarnings) { | |
| 317 extensions::TestExtensionRegistryObserver observer( | |
| 318 ExtensionRegistry::Get(profile())); | |
| 319 | |
| 320 scoped_refptr<EphemeralAppLauncherForTest> launcher( | |
| 321 new EphemeralAppLauncherForTest(kDefaultAppId, profile())); | |
| 322 StartLauncherAndCheckResult(launcher.get(), webstore_install::SUCCESS, true); | |
| 323 ValidateAppInstalledEphemerally(kDefaultAppId); | |
| 324 | |
| 325 // Apps with no permission warnings should not result in a prompt. | |
| 326 EXPECT_FALSE(launcher->install_prompt_created()); | |
| 327 | |
| 328 // Ephemeral apps are unloaded after they stop running. | |
| 329 observer.WaitForExtensionUnloaded(); | |
| 330 | |
| 331 // After an app has been installed ephemerally, it can be launched again | |
| 332 // without installing from the web store. | |
| 333 RunLaunchTest(kDefaultAppId, webstore_install::SUCCESS, false); | |
| 334 } | |
| 335 | |
| 336 // Verifies that an app with permission warnings will be installed | |
| 337 // ephemerally and launched if accepted by the user. | |
| 338 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, | |
| 339 LaunchAppWithPermissionsWarnings) { | |
| 340 SetCrxFilename(kAppWithPermissionsFilename); | |
| 341 AutoAcceptInstall(); | |
| 342 | |
| 343 scoped_refptr<EphemeralAppLauncherForTest> launcher( | |
| 344 new EphemeralAppLauncherForTest(kAppWithPermissionsId, profile())); | |
| 345 StartLauncherAndCheckResult(launcher.get(), webstore_install::SUCCESS, true); | |
| 346 ValidateAppInstalledEphemerally(kAppWithPermissionsId); | |
| 347 EXPECT_TRUE(launcher->install_prompt_created()); | |
| 348 } | |
| 349 | |
| 350 // Verifies that an app with permission warnings will not be installed | |
| 351 // ephemerally if cancelled by the user. | |
| 352 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, | |
| 353 CancelInstallAppWithPermissionWarnings) { | |
| 354 SetCrxFilename(kAppWithPermissionsFilename); | |
| 355 AutoCancelInstall(); | |
| 356 | |
| 357 scoped_refptr<EphemeralAppLauncherForTest> launcher( | |
| 358 new EphemeralAppLauncherForTest(kAppWithPermissionsId, profile())); | |
| 359 StartLauncherAndCheckResult( | |
| 360 launcher.get(), webstore_install::USER_CANCELLED, false); | |
| 361 EXPECT_FALSE(GetInstalledExtension(kAppWithPermissionsId)); | |
| 362 EXPECT_TRUE(launcher->install_prompt_created()); | |
| 363 } | |
| 364 | |
| 365 // Verifies that an extension will not be installed ephemerally. | |
| 366 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, InstallExtension) { | |
| 367 RunLaunchTest( | |
| 368 kExtensionId, webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE, false); | |
| 369 EXPECT_FALSE(GetInstalledExtension(kExtensionId)); | |
| 370 } | |
| 371 | |
| 372 // Verifies that an already installed extension will not be launched. | |
| 373 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchExtension) { | |
| 374 const Extension* extension = | |
| 375 InstallExtension(GetTestPath(kExtensionTestPath), 1); | |
| 376 ASSERT_TRUE(extension); | |
| 377 RunLaunchTest(extension->id(), | |
| 378 webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE, | |
| 379 false); | |
| 380 } | |
| 381 | |
| 382 // Verifies that a legacy packaged app will not be installed ephemerally. | |
| 383 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, InstallLegacyApp) { | |
| 384 RunLaunchTest( | |
| 385 kLegacyAppId, webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE, false); | |
| 386 EXPECT_FALSE(GetInstalledExtension(kLegacyAppId)); | |
| 387 } | |
| 388 | |
| 389 // Verifies that a legacy packaged app that is already installed can be | |
| 390 // launched. | |
| 391 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchLegacyApp) { | |
| 392 const Extension* extension = | |
| 393 InstallExtension(GetTestPath(kLegacyAppTestPath), 1); | |
| 394 ASSERT_TRUE(extension); | |
| 395 RunLaunchTest(extension->id(), webstore_install::SUCCESS, false); | |
| 396 } | |
| 397 | |
| 398 // Verifies that a hosted app is not installed. Launch succeeds because we | |
| 399 // navigate to its launch url. | |
| 400 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchHostedApp) { | |
| 401 LaunchObserver launch_observer; | |
| 402 | |
| 403 scoped_refptr<EphemeralAppLauncherForTest> launcher( | |
| 404 new EphemeralAppLauncherForTest( | |
| 405 kHostedAppId, | |
| 406 profile(), | |
| 407 base::Bind(&LaunchObserver::OnLaunchCallback, | |
| 408 base::Unretained(&launch_observer)))); | |
| 409 launcher->Start(); | |
| 410 launch_observer.Wait(); | |
| 411 | |
| 412 EXPECT_EQ(webstore_install::SUCCESS, launch_observer.result()); | |
| 413 EXPECT_FALSE(launcher->install_initiated()); | |
| 414 EXPECT_FALSE(GetInstalledExtension(kHostedAppId)); | |
| 415 | |
| 416 // Verify that a navigation to the launch url was attempted. | |
| 417 Browser* browser = | |
| 418 FindBrowserWithProfile(profile(), chrome::GetActiveDesktop()); | |
| 419 ASSERT_TRUE(browser); | |
| 420 content::WebContents* web_contents = | |
| 421 browser->tab_strip_model()->GetActiveWebContents(); | |
| 422 ASSERT_TRUE(web_contents); | |
| 423 EXPECT_EQ(GURL(kHostedAppLaunchUrl), web_contents->GetVisibleURL()); | |
| 424 } | |
| 425 | |
| 426 // Verifies that the EphemeralAppLauncher handles non-existent extension ids. | |
| 427 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, NonExistentExtensionId) { | |
| 428 RunLaunchTest( | |
| 429 kNonExistentId, webstore_install::WEBSTORE_REQUEST_ERROR, false); | |
| 430 EXPECT_FALSE(GetInstalledExtension(kNonExistentId)); | |
| 431 } | |
| 432 | |
| 433 // Verifies that an app blocked by management policy is not installed | |
| 434 // ephemerally. | |
| 435 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, BlockedByPolicy) { | |
| 436 // Register a provider that blocks the installation of all apps. | |
| 437 ManagementPolicyMock policy; | |
| 438 ExtensionSystem::Get(profile())->management_policy()->RegisterProvider( | |
| 439 &policy); | |
| 440 | |
| 441 RunLaunchTest(kDefaultAppId, webstore_install::BLOCKED_BY_POLICY, false); | |
| 442 EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); | |
| 443 } | |
| 444 | |
| 445 // The blacklist relies on safe-browsing database infrastructure. | |
| 446 #if defined(SAFE_BROWSING_DB_LOCAL) | |
| 447 // Verifies that an app blacklisted for malware is not installed ephemerally. | |
| 448 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, BlacklistedForMalware) { | |
| 449 // Mock a BLACKLISTED_MALWARE return status. | |
| 450 extensions::TestBlacklist blacklist_tester( | |
| 451 extensions::Blacklist::Get(profile())); | |
| 452 blacklist_tester.SetBlacklistState( | |
| 453 kDefaultAppId, extensions::BLACKLISTED_MALWARE, false); | |
| 454 | |
| 455 RunLaunchTest(kDefaultAppId, webstore_install::BLACKLISTED, false); | |
| 456 EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); | |
| 457 } | |
| 458 | |
| 459 // Verifies that an app with unknown blacklist status is installed ephemerally | |
| 460 // and launched. | |
| 461 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, BlacklistStateUnknown) { | |
| 462 // Mock a BLACKLISTED_MALWARE return status. | |
| 463 extensions::TestBlacklist blacklist_tester( | |
| 464 extensions::Blacklist::Get(profile())); | |
| 465 blacklist_tester.SetBlacklistState( | |
| 466 kDefaultAppId, extensions::BLACKLISTED_UNKNOWN, false); | |
| 467 | |
| 468 RunLaunchTest(kDefaultAppId, webstore_install::SUCCESS, true); | |
| 469 ValidateAppInstalledEphemerally(kDefaultAppId); | |
| 470 } | |
| 471 #endif | |
| 472 | |
| 473 // Verifies that an app with unsupported requirements is not installed | |
| 474 // ephemerally. | |
| 475 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, UnsupportedRequirements) { | |
| 476 scoped_refptr<EphemeralAppLauncherForTest> launcher( | |
| 477 new EphemeralAppLauncherForTest(kDefaultAppId, profile())); | |
| 478 launcher->set_requirements_error("App has unsupported requirements"); | |
| 479 | |
| 480 StartLauncherAndCheckResult( | |
| 481 launcher.get(), webstore_install::REQUIREMENT_VIOLATIONS, false); | |
| 482 EXPECT_FALSE(GetInstalledExtension(kDefaultAppId)); | |
| 483 } | |
| 484 | |
| 485 // Verifies that an app disabled due to permissions increase can be enabled | |
| 486 // and launched. | |
| 487 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, EnableAndLaunchApp) { | |
| 488 const Extension* app = InstallAndDisableApp( | |
| 489 kDefaultAppTestPath, Extension::DISABLE_PERMISSIONS_INCREASE); | |
| 490 ASSERT_TRUE(app); | |
| 491 | |
| 492 AutoAcceptInstall(); | |
| 493 RunLaunchTest(app->id(), webstore_install::SUCCESS, false); | |
| 494 } | |
| 495 | |
| 496 // Verifies that if the user cancels the enable flow, the app will not be | |
| 497 // enabled and launched. | |
| 498 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, EnableCancelled) { | |
| 499 const Extension* app = InstallAndDisableApp( | |
| 500 kDefaultAppTestPath, Extension::DISABLE_PERMISSIONS_INCREASE); | |
| 501 ASSERT_TRUE(app); | |
| 502 | |
| 503 AutoCancelInstall(); | |
| 504 RunLaunchTest(app->id(), webstore_install::USER_CANCELLED, false); | |
| 505 } | |
| 506 | |
| 507 // Verifies that an installed app that had been blocked by policy cannot be | |
| 508 // launched. | |
| 509 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchAppBlockedByPolicy) { | |
| 510 const Extension* app = InstallExtension(GetTestPath(kDefaultAppTestPath), 1); | |
| 511 ASSERT_TRUE(app); | |
| 512 | |
| 513 // Simulate blocking of the app after it has been installed. | |
| 514 ManagementPolicyMock policy; | |
| 515 ExtensionSystem::Get(profile())->management_policy()->RegisterProvider( | |
| 516 &policy); | |
| 517 ExtensionSystem::Get(profile())->extension_service()->CheckManagementPolicy(); | |
| 518 | |
| 519 RunLaunchTest(app->id(), webstore_install::BLOCKED_BY_POLICY, false); | |
| 520 } | |
| 521 | |
| 522 // Verifies that an installed blacklisted app cannot be launched. | |
| 523 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, LaunchBlacklistedApp) { | |
| 524 const Extension* app = InstallExtension(GetTestPath(kDefaultAppTestPath), 1); | |
| 525 ASSERT_TRUE(app); | |
| 526 | |
| 527 ExtensionService* service = | |
| 528 ExtensionSystem::Get(profile())->extension_service(); | |
| 529 service->BlacklistExtensionForTest(app->id()); | |
| 530 ASSERT_TRUE( | |
| 531 ExtensionRegistry::Get(profile())->blacklisted_extensions().Contains( | |
| 532 app->id())); | |
| 533 | |
| 534 RunLaunchTest(app->id(), webstore_install::BLACKLISTED, false); | |
| 535 } | |
| 536 | |
| 537 // Verifies that an installed app with unsupported requirements cannot be | |
| 538 // launched. | |
| 539 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, | |
| 540 LaunchAppWithUnsupportedRequirements) { | |
| 541 const Extension* app = InstallAndDisableApp( | |
| 542 kDefaultAppTestPath, Extension::DISABLE_UNSUPPORTED_REQUIREMENT); | |
| 543 ASSERT_TRUE(app); | |
| 544 | |
| 545 RunLaunchTest(app->id(), webstore_install::REQUIREMENT_VIOLATIONS, false); | |
| 546 } | |
| 547 | |
| 548 // Verifies that a launch will fail if the app is currently being installed. | |
| 549 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, InstallInProgress) { | |
| 550 extensions::ActiveInstallData install_data(kDefaultAppId); | |
| 551 InstallTracker::Get(profile())->AddActiveInstall(install_data); | |
| 552 | |
| 553 RunLaunchTest(kDefaultAppId, webstore_install::INSTALL_IN_PROGRESS, false); | |
| 554 } | |
| 555 | |
| 556 // Verifies that a launch will fail if a duplicate launch is in progress. | |
| 557 IN_PROC_BROWSER_TEST_F(EphemeralAppLauncherTest, DuplicateLaunchInProgress) { | |
| 558 extensions::ActiveInstallData install_data(kDefaultAppId); | |
| 559 install_data.is_ephemeral = true; | |
| 560 InstallTracker::Get(profile())->AddActiveInstall(install_data); | |
| 561 | |
| 562 RunLaunchTest(kDefaultAppId, webstore_install::LAUNCH_IN_PROGRESS, false); | |
| 563 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1395043002:
Remove ability for users to launch ephemeral apps. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master