management_browsertest.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d
1// Copyright (c) 2012 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/bind.h" 6#include "base/bind_helpers.h" 7#include "base/memory/ref_counted.h" 8#include "base/prefs/pref_service.h" 9#include "base/stl_util.h" 10#include "chrome/browser/extensions/extension_browsertest.h" 11#include "chrome/browser/extensions/extension_host.h" 12#include "chrome/browser/extensions/extension_service.h" 13#include "chrome/browser/extensions/extension_system.h" 14#include "chrome/browser/extensions/extension_test_message_listener.h" 15#include "chrome/browser/extensions/external_policy_loader.h" 16#include "chrome/browser/extensions/updater/extension_downloader.h" 17#include "chrome/browser/extensions/updater/extension_updater.h" 18#include "chrome/browser/prefs/scoped_user_pref_update.h" 19#include "chrome/browser/profiles/profile.h" 20#include "chrome/browser/ui/browser.h" 21#include "chrome/common/chrome_notification_types.h" 22#include "chrome/common/pref_names.h" 23#include "chrome/common/url_constants.h" 24#include "chrome/test/base/ui_test_utils.h" 25#include "content/public/browser/notification_service.h" 26#include "content/public/browser/render_view_host.h" 27#include "content/public/test/browser_test_utils.h" 28#include "content/test/net/url_request_prepackaged_interceptor.h" 29#include "net/url_request/url_fetcher.h" 30 31using extensions::Extension; 32using extensions::Manifest; 33 34class ExtensionManagementTest : public ExtensionBrowserTest { 35 protected: 36 // Helper method that returns whether the extension is at the given version. 37 // This calls version(), which must be defined in the extension's bg page, 38 // as well as asking the extension itself. 39 // 40 // Note that 'version' here means something different than the version field 41 // in the extension's manifest. We use the version as reported by the 42 // background page to test how overinstalling crx files with the same 43 // manifest version works. 44 bool IsExtensionAtVersion(const Extension* extension, 45 const std::string& expected_version) { 46 // Test that the extension's version from the manifest and reported by the 47 // background page is correct. This is to ensure that the processes are in 48 // sync with the Extension. 49 ExtensionProcessManager* manager = 50 extensions::ExtensionSystem::Get(browser()->profile())-> 51 process_manager(); 52 extensions::ExtensionHost* ext_host = 53 manager->GetBackgroundHostForExtension(extension->id()); 54 EXPECT_TRUE(ext_host); 55 if (!ext_host) 56 return false; 57 58 std::string version_from_bg; 59 bool exec = content::ExecuteScriptAndExtractString( 60 ext_host->render_view_host(), "version()", &version_from_bg); 61 EXPECT_TRUE(exec); 62 if (!exec) 63 return false; 64 65 if (version_from_bg != expected_version || 66 extension->VersionString() != expected_version) 67 return false; 68 return true; 69 } 70}; 71 72#if defined(OS_LINUX) 73// Times out sometimes on Linux. http://crbug.com/89727 74#define MAYBE_InstallSameVersion DISABLED_InstallSameVersion 75#else 76#define MAYBE_InstallSameVersion InstallSameVersion 77#endif 78 79// Tests that installing the same version overwrites. 80IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, MAYBE_InstallSameVersion) { 81 const Extension* extension = InstallExtension( 82 test_data_dir_.AppendASCII("install/install.crx"), 1); 83 ASSERT_TRUE(extension); 84 base::FilePath old_path = extension->path(); 85 86 // Install an extension with the same version. The previous install should be 87 // overwritten. 88 extension = InstallExtension( 89 test_data_dir_.AppendASCII("install/install_same_version.crx"), 0); 90 ASSERT_TRUE(extension); 91 base::FilePath new_path = extension->path(); 92 93 EXPECT_FALSE(IsExtensionAtVersion(extension, "1.0")); 94 EXPECT_NE(old_path.value(), new_path.value()); 95} 96 97IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, InstallOlderVersion) { 98 const Extension* extension = InstallExtension( 99 test_data_dir_.AppendASCII("install/install.crx"), 1); 100 ASSERT_TRUE(extension); 101 ASSERT_FALSE(InstallExtension( 102 test_data_dir_.AppendASCII("install/install_older_version.crx"), 0)); 103 EXPECT_TRUE(IsExtensionAtVersion(extension, "1.0")); 104} 105 106IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, InstallThenCancel) { 107 const Extension* extension = InstallExtension( 108 test_data_dir_.AppendASCII("install/install.crx"), 1); 109 ASSERT_TRUE(extension); 110 111 // Cancel this install. 112 ASSERT_FALSE(StartInstallButCancel( 113 test_data_dir_.AppendASCII("install/install_v2.crx"))); 114 EXPECT_TRUE(IsExtensionAtVersion(extension, "1.0")); 115} 116 117#if defined(OS_WIN) 118// http://crbug.com/141913 119#define MAYBE_InstallRequiresConfirm DISABLED_InstallRequiresConfirm 120#else 121#define MAYBE_InstallRequiresConfirm InstallRequiresConfirm 122#endif 123IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, MAYBE_InstallRequiresConfirm) { 124 // Installing the extension without an auto confirming UI should result in 125 // it being disabled, since good.crx has permissions that require approval. 126 ExtensionService* service = extensions::ExtensionSystem::Get( 127 browser()->profile())->extension_service(); 128 std::string id = "ldnnhddmnhbkjipkidpdiheffobcpfmf"; 129 ASSERT_FALSE(InstallExtension(test_data_dir_.AppendASCII("good.crx"), 0)); 130 ASSERT_TRUE(service->GetExtensionById(id, true)); 131 UninstallExtension(id); 132 133 // And the install should succeed when the permissions are accepted. 134 ASSERT_TRUE(InstallExtensionWithUIAutoConfirm( 135 test_data_dir_.AppendASCII("good.crx"), 1, browser())); 136 UninstallExtension(id); 137} 138 139// Tests that disabling and re-enabling an extension works. 140IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, DisableEnable) { 141 ExtensionProcessManager* manager = 142 extensions::ExtensionSystem::Get(browser()->profile())->process_manager(); 143 ExtensionService* service = extensions::ExtensionSystem::Get( 144 browser()->profile())->extension_service(); 145 const size_t size_before = service->extensions()->size(); 146 147 // Load an extension, expect the background page to be available. 148 std::string extension_id = "bjafgdebaacbbbecmhlhpofkepfkgcpa"; 149 ASSERT_TRUE(LoadExtension( 150 test_data_dir_.AppendASCII("good").AppendASCII("Extensions") 151 .AppendASCII(extension_id) 152 .AppendASCII("1.0"))); 153 ASSERT_EQ(size_before + 1, service->extensions()->size()); 154 EXPECT_EQ(0u, service->disabled_extensions()->size()); 155 EXPECT_TRUE(manager->GetBackgroundHostForExtension(extension_id)); 156 157 // After disabling, the background page should go away. 158 DisableExtension(extension_id); 159 EXPECT_EQ(size_before, service->extensions()->size()); 160 EXPECT_EQ(1u, service->disabled_extensions()->size()); 161 EXPECT_FALSE(manager->GetBackgroundHostForExtension(extension_id)); 162 163 // And bring it back. 164 EnableExtension(extension_id); 165 EXPECT_EQ(size_before + 1, service->extensions()->size()); 166 EXPECT_EQ(0u, service->disabled_extensions()->size()); 167 EXPECT_TRUE(manager->GetBackgroundHostForExtension(extension_id)); 168} 169 170// Used for testing notifications sent during extension updates. 171class NotificationListener : public content::NotificationObserver { 172 public: 173 NotificationListener() : started_(false), finished_(false) { 174 int types[] = { 175 chrome::NOTIFICATION_EXTENSION_UPDATING_STARTED, 176 chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND 177 }; 178 for (size_t i = 0; i < arraysize(types); i++) { 179 registrar_.Add( 180 this, types[i], content::NotificationService::AllSources()); 181 } 182 } 183 virtual ~NotificationListener() {} 184 185 bool started() { return started_; } 186 187 bool finished() { return finished_; } 188 189 const std::set<std::string>& updates() { return updates_; } 190 191 void Reset() { 192 started_ = false; 193 finished_ = false; 194 updates_.clear(); 195 } 196 197 // Implements content::NotificationObserver interface. 198 virtual void Observe(int type, 199 const content::NotificationSource& source, 200 const content::NotificationDetails& details) OVERRIDE { 201 switch (type) { 202 case chrome::NOTIFICATION_EXTENSION_UPDATING_STARTED: { 203 EXPECT_FALSE(started_); 204 started_ = true; 205 break; 206 } 207 case chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND: { 208 const std::string& id = 209 content::Details<extensions::UpdateDetails>(details)->id; 210 updates_.insert(id); 211 break; 212 } 213 default: 214 NOTREACHED(); 215 } 216 } 217 218 void OnFinished() { 219 EXPECT_FALSE(finished_); 220 finished_ = true; 221 } 222 223 private: 224 content::NotificationRegistrar registrar_; 225 226 // Did we see EXTENSION_UPDATING_STARTED? 227 bool started_; 228 229 // Did we see EXTENSION_UPDATING_FINISHED? 230 bool finished_; 231 232 // The set of extension id's we've seen via EXTENSION_UPDATE_FOUND. 233 std::set<std::string> updates_; 234}; 235 236#if defined(OS_WIN) 237// Fails consistently on Windows XP, see: http://crbug.com/120640. 238#define MAYBE_AutoUpdate DISABLED_AutoUpdate 239#else 240// See http://crbug.com/103371 and http://crbug.com/120640. 241#if defined(ADDRESS_SANITIZER) 242#define MAYBE_AutoUpdate DISABLED_AutoUpdate 243#else 244#define MAYBE_AutoUpdate AutoUpdate 245#endif 246#endif 247 248// Tests extension autoupdate. 249IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, MAYBE_AutoUpdate) { 250 NotificationListener notification_listener; 251 base::FilePath basedir = test_data_dir_.AppendASCII("autoupdate"); 252 // Note: This interceptor gets requests on the IO thread. 253 content::URLLocalHostRequestPrepackagedInterceptor interceptor; 254 net::URLFetcher::SetEnableInterceptionForTests(true); 255 256 interceptor.SetResponseIgnoreQuery( 257 GURL("http://localhost/autoupdate/manifest"), 258 basedir.AppendASCII("manifest_v2.xml")); 259 interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"), 260 basedir.AppendASCII("v2.crx")); 261 262 // Install version 1 of the extension. 263 ExtensionTestMessageListener listener1("v1 installed", false); 264 ExtensionService* service = extensions::ExtensionSystem::Get( 265 browser()->profile())->extension_service(); 266 const size_t size_before = service->extensions()->size(); 267 ASSERT_TRUE(service->disabled_extensions()->is_empty()); 268 const Extension* extension = 269 InstallExtension(basedir.AppendASCII("v1.crx"), 1); 270 ASSERT_TRUE(extension); 271 listener1.WaitUntilSatisfied(); 272 ASSERT_EQ(size_before + 1, service->extensions()->size()); 273 ASSERT_EQ("ogjcoiohnmldgjemafoockdghcjciccf", extension->id()); 274 ASSERT_EQ("1.0", extension->VersionString()); 275 276 // We don't want autoupdate blacklist checks. 277 extensions::ExtensionUpdater::CheckParams params; 278 params.check_blacklist = false; 279 params.callback = 280 base::Bind(&NotificationListener::OnFinished, 281 base::Unretained(¬ification_listener)); 282 283 // Run autoupdate and make sure version 2 of the extension was installed. 284 ExtensionTestMessageListener listener2("v2 installed", false); 285 service->updater()->CheckNow(params); 286 ASSERT_TRUE(WaitForExtensionInstall()); 287 listener2.WaitUntilSatisfied(); 288 ASSERT_EQ(size_before + 1, service->extensions()->size()); 289 extension = service->GetExtensionById( 290 "ogjcoiohnmldgjemafoockdghcjciccf", false); 291 ASSERT_TRUE(extension); 292 ASSERT_EQ("2.0", extension->VersionString()); 293 ASSERT_TRUE(notification_listener.started()); 294 ASSERT_TRUE(notification_listener.finished()); 295 ASSERT_TRUE(ContainsKey(notification_listener.updates(), 296 "ogjcoiohnmldgjemafoockdghcjciccf")); 297 notification_listener.Reset(); 298 299 // Now try doing an update to version 3, which has been incorrectly 300 // signed. This should fail. 301 interceptor.SetResponseIgnoreQuery( 302 GURL("http://localhost/autoupdate/manifest"), 303 basedir.AppendASCII("manifest_v3.xml")); 304 interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v3.crx"), 305 basedir.AppendASCII("v3.crx")); 306 307 service->updater()->CheckNow(params); 308 ASSERT_TRUE(WaitForExtensionInstallError()); 309 ASSERT_TRUE(notification_listener.started()); 310 ASSERT_TRUE(notification_listener.finished()); 311 ASSERT_TRUE(ContainsKey(notification_listener.updates(), 312 "ogjcoiohnmldgjemafoockdghcjciccf")); 313 314 // Make sure the extension state is the same as before. 315 ASSERT_EQ(size_before + 1, service->extensions()->size()); 316 extension = service->GetExtensionById( 317 "ogjcoiohnmldgjemafoockdghcjciccf", false); 318 ASSERT_TRUE(extension); 319 ASSERT_EQ("2.0", extension->VersionString()); 320} 321 322#if defined(OS_WIN) 323// Fails consistently on Windows XP, see: http://crbug.com/120640. 324#define MAYBE_AutoUpdateDisabledExtensions DISABLED_AutoUpdateDisabledExtensions 325#else 326#if defined(ADDRESS_SANITIZER) 327#define MAYBE_AutoUpdateDisabledExtensions DISABLED_AutoUpdateDisabledExtensions 328#else 329#define MAYBE_AutoUpdateDisabledExtensions AutoUpdateDisabledExtensions 330#endif 331#endif 332 333// Tests extension autoupdate. 334IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, 335 MAYBE_AutoUpdateDisabledExtensions) { 336 NotificationListener notification_listener; 337 base::FilePath basedir = test_data_dir_.AppendASCII("autoupdate"); 338 // Note: This interceptor gets requests on the IO thread. 339 content::URLLocalHostRequestPrepackagedInterceptor interceptor; 340 net::URLFetcher::SetEnableInterceptionForTests(true); 341 342 interceptor.SetResponseIgnoreQuery( 343 GURL("http://localhost/autoupdate/manifest"), 344 basedir.AppendASCII("manifest_v2.xml")); 345 interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"), 346 basedir.AppendASCII("v2.crx")); 347 348 // Install version 1 of the extension. 349 ExtensionTestMessageListener listener1("v1 installed", false); 350 ExtensionService* service = extensions::ExtensionSystem::Get( 351 browser()->profile())->extension_service(); 352 const size_t enabled_size_before = service->extensions()->size(); 353 const size_t disabled_size_before = service->disabled_extensions()->size(); 354 const Extension* extension = 355 InstallExtension(basedir.AppendASCII("v1.crx"), 1); 356 ASSERT_TRUE(extension); 357 listener1.WaitUntilSatisfied(); 358 DisableExtension(extension->id()); 359 ASSERT_EQ(disabled_size_before + 1, service->disabled_extensions()->size()); 360 ASSERT_EQ(enabled_size_before, service->extensions()->size()); 361 ASSERT_EQ("ogjcoiohnmldgjemafoockdghcjciccf", extension->id()); 362 ASSERT_EQ("1.0", extension->VersionString()); 363 364 // We don't want autoupdate blacklist checks. 365 extensions::ExtensionUpdater::CheckParams params; 366 params.check_blacklist = false; 367 params.callback = 368 base::Bind(&NotificationListener::OnFinished, 369 base::Unretained(¬ification_listener)); 370 371 ExtensionTestMessageListener listener2("v2 installed", false); 372 // Run autoupdate and make sure version 2 of the extension was installed but 373 // is still disabled. 374 service->updater()->CheckNow(params); 375 ASSERT_TRUE(WaitForExtensionInstall()); 376 ASSERT_EQ(disabled_size_before + 1, service->disabled_extensions()->size()); 377 ASSERT_EQ(enabled_size_before, service->extensions()->size()); 378 extension = service->GetExtensionById( 379 "ogjcoiohnmldgjemafoockdghcjciccf", true); 380 ASSERT_TRUE(extension); 381 ASSERT_FALSE(service->GetExtensionById( 382 "ogjcoiohnmldgjemafoockdghcjciccf", false)); 383 ASSERT_EQ("2.0", extension->VersionString()); 384 385 // The extension should have not made the callback because it is disabled. 386 // When we enabled it, it should then make the callback. 387 ASSERT_FALSE(listener2.was_satisfied()); 388 EnableExtension(extension->id()); 389 listener2.WaitUntilSatisfied(); 390 ASSERT_TRUE(notification_listener.started()); 391 ASSERT_TRUE(notification_listener.finished()); 392 ASSERT_TRUE(ContainsKey(notification_listener.updates(), 393 "ogjcoiohnmldgjemafoockdghcjciccf")); 394 notification_listener.Reset(); 395} 396 397// TODO(linux_aura) http://crbug.com/163931 398#if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_AURA) 399#define MAYBE_ExternalUrlUpdate DISABLED_ExternalUrlUpdate 400#else 401#define MAYBE_ExternalUrlUpdate ExternalUrlUpdate 402#endif 403 404IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, MAYBE_ExternalUrlUpdate) { 405 ExtensionService* service = extensions::ExtensionSystem::Get( 406 browser()->profile())->extension_service(); 407 const char* kExtensionId = "ogjcoiohnmldgjemafoockdghcjciccf"; 408 // We don't want autoupdate blacklist checks. 409 extensions::ExtensionUpdater::CheckParams params; 410 params.check_blacklist = false; 411 412 base::FilePath basedir = test_data_dir_.AppendASCII("autoupdate"); 413 414 // Note: This interceptor gets requests on the IO thread. 415 content::URLLocalHostRequestPrepackagedInterceptor interceptor; 416 net::URLFetcher::SetEnableInterceptionForTests(true); 417 418 interceptor.SetResponseIgnoreQuery( 419 GURL("http://localhost/autoupdate/manifest"), 420 basedir.AppendASCII("manifest_v2.xml")); 421 interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"), 422 basedir.AppendASCII("v2.crx")); 423 424 const size_t size_before = service->extensions()->size(); 425 ASSERT_TRUE(service->disabled_extensions()->is_empty()); 426 427 extensions::PendingExtensionManager* pending_extension_manager = 428 service->pending_extension_manager(); 429 430 // The code that reads external_extensions.json uses this method to inform 431 // the ExtensionService of an extension to download. Using the real code 432 // is race-prone, because instantating the ExtensionService starts a read 433 // of external_extensions.json before this test function starts. 434 435 EXPECT_TRUE(pending_extension_manager->AddFromExternalUpdateUrl( 436 kExtensionId, GURL("http://localhost/autoupdate/manifest"), 437 Manifest::EXTERNAL_PREF_DOWNLOAD)); 438 439 // Run autoupdate and make sure version 2 of the extension was installed. 440 service->updater()->CheckNow(params); 441 ASSERT_TRUE(WaitForExtensionInstall()); 442 ASSERT_EQ(size_before + 1, service->extensions()->size()); 443 const Extension* extension = service->GetExtensionById(kExtensionId, false); 444 ASSERT_TRUE(extension); 445 ASSERT_EQ("2.0", extension->VersionString()); 446 447 // Uninstalling the extension should set a pref that keeps the extension from 448 // being installed again the next time external_extensions.json is read. 449 450 UninstallExtension(kExtensionId); 451 452 extensions::ExtensionPrefs* extension_prefs = service->extension_prefs(); 453 EXPECT_TRUE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId)) 454 << "Uninstalling should set kill bit on externaly installed extension."; 455 456 // Try to install the extension again from an external source. It should fail 457 // because of the killbit. 458 EXPECT_FALSE(pending_extension_manager->AddFromExternalUpdateUrl( 459 kExtensionId, GURL("http://localhost/autoupdate/manifest"), 460 Manifest::EXTERNAL_PREF_DOWNLOAD)); 461 EXPECT_FALSE(pending_extension_manager->IsIdPending(kExtensionId)) 462 << "External reinstall of a killed extension shouldn't work."; 463 EXPECT_TRUE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId)) 464 << "External reinstall of a killed extension should leave it killed."; 465 466 // Installing from non-external source. 467 ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1)); 468 469 EXPECT_FALSE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId)) 470 << "Reinstalling should clear the kill bit."; 471 472 // Uninstalling from a non-external source should not set the kill bit. 473 UninstallExtension(kExtensionId); 474 475 EXPECT_FALSE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId)) 476 << "Uninstalling non-external extension should not set kill bit."; 477} 478 479namespace { 480 481const char* kForceInstallNotEmptyHelp = 482 "A policy may already be controlling the list of force-installed " 483 "extensions. Please remove all policy settings from your computer " 484 "before running tests. E.g. from /etc/chromium/policies Linux or " 485 "from the registry on Windows, etc."; 486 487} 488 489// See http://crbug.com/57378 for flakiness details. 490IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, ExternalPolicyRefresh) { 491 ExtensionService* service = extensions::ExtensionSystem::Get( 492 browser()->profile())->extension_service(); 493 const char* kExtensionId = "ogjcoiohnmldgjemafoockdghcjciccf"; 494 // We don't want autoupdate blacklist checks. 495 extensions::ExtensionUpdater::CheckParams params; 496 params.check_blacklist = false; 497 498 base::FilePath basedir = test_data_dir_.AppendASCII("autoupdate"); 499 500 // Note: This interceptor gets requests on the IO thread. 501 content::URLLocalHostRequestPrepackagedInterceptor interceptor; 502 net::URLFetcher::SetEnableInterceptionForTests(true); 503 504 interceptor.SetResponseIgnoreQuery( 505 GURL("http://localhost/autoupdate/manifest"), 506 basedir.AppendASCII("manifest_v2.xml")); 507 interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"), 508 basedir.AppendASCII("v2.crx")); 509 510 const size_t size_before = service->extensions()->size(); 511 ASSERT_TRUE(service->disabled_extensions()->is_empty()); 512 513 PrefService* prefs = browser()->profile()->GetPrefs(); 514 const DictionaryValue* forcelist = 515 prefs->GetDictionary(prefs::kExtensionInstallForceList); 516 ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp; 517 518 { 519 // Set the policy as a user preference and fire notification observers. 520 DictionaryPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList); 521 DictionaryValue* forcelist = pref_update.Get(); 522 extensions::ExternalPolicyLoader::AddExtension( 523 forcelist, kExtensionId, "http://localhost/autoupdate/manifest"); 524 } 525 526 // Check if the extension got installed. 527 ASSERT_TRUE(WaitForExtensionInstall()); 528 ASSERT_EQ(size_before + 1, service->extensions()->size()); 529 const Extension* extension = service->GetExtensionById(kExtensionId, false); 530 ASSERT_TRUE(extension); 531 ASSERT_EQ("2.0", extension->VersionString()); 532 EXPECT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD, extension->location()); 533 534 // Try to disable and uninstall the extension which should fail. 535 DisableExtension(kExtensionId); 536 EXPECT_EQ(size_before + 1, service->extensions()->size()); 537 EXPECT_EQ(0u, service->disabled_extensions()->size()); 538 UninstallExtension(kExtensionId); 539 EXPECT_EQ(size_before + 1, service->extensions()->size()); 540 EXPECT_EQ(0u, service->disabled_extensions()->size()); 541 542 // Now try to disable it through the management api, again failing. 543 ExtensionTestMessageListener listener1("ready", false); 544 ASSERT_TRUE(LoadExtension( 545 test_data_dir_.AppendASCII("management/uninstall_extension"))); 546 ASSERT_TRUE(listener1.WaitUntilSatisfied()); 547 EXPECT_EQ(size_before + 2, service->extensions()->size()); 548 EXPECT_EQ(0u, service->disabled_extensions()->size()); 549 550 // Check that emptying the list triggers uninstall. 551 prefs->ClearPref(prefs::kExtensionInstallForceList); 552 EXPECT_EQ(size_before + 1, service->extensions()->size()); 553 EXPECT_FALSE(service->GetExtensionById(kExtensionId, true)); 554} 555 556// See http://crbug.com/103371 and http://crbug.com/120640. 557#if defined(ADDRESS_SANITIZER) 558#define MAYBE_PolicyOverridesUserInstall DISABLED_PolicyOverridesUserInstall 559#else 560#define MAYBE_PolicyOverridesUserInstall PolicyOverridesUserInstall 561#endif 562 563IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, 564 MAYBE_PolicyOverridesUserInstall) { 565 ExtensionService* service = extensions::ExtensionSystem::Get( 566 browser()->profile())->extension_service(); 567 const char* kExtensionId = "ogjcoiohnmldgjemafoockdghcjciccf"; 568 extensions::ExtensionUpdater::CheckParams params; 569 params.check_blacklist = false; 570 service->updater()->set_default_check_params(params); 571 const size_t size_before = service->extensions()->size(); 572 base::FilePath basedir = test_data_dir_.AppendASCII("autoupdate"); 573 ASSERT_TRUE(service->disabled_extensions()->is_empty()); 574 575 // Note: This interceptor gets requests on the IO thread. 576 content::URLLocalHostRequestPrepackagedInterceptor interceptor; 577 net::URLFetcher::SetEnableInterceptionForTests(true); 578 579 interceptor.SetResponseIgnoreQuery( 580 GURL("http://localhost/autoupdate/manifest"), 581 basedir.AppendASCII("manifest_v2.xml")); 582 interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"), 583 basedir.AppendASCII("v2.crx")); 584 585 // Check that the policy is initially empty. 586 PrefService* prefs = browser()->profile()->GetPrefs(); 587 const DictionaryValue* forcelist = 588 prefs->GetDictionary(prefs::kExtensionInstallForceList); 589 ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp; 590 591 // User install of the extension. 592 ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1)); 593 ASSERT_EQ(size_before + 1, service->extensions()->size()); 594 const Extension* extension = service->GetExtensionById(kExtensionId, false); 595 ASSERT_TRUE(extension); 596 EXPECT_EQ(Manifest::INTERNAL, extension->location()); 597 EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId)); 598 599 // Setup the force install policy. It should override the location. 600 { 601 DictionaryPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList); 602 extensions::ExternalPolicyLoader::AddExtension( 603 pref_update.Get(), kExtensionId, 604 "http://localhost/autoupdate/manifest"); 605 } 606 ASSERT_TRUE(WaitForExtensionInstall()); 607 ASSERT_EQ(size_before + 1, service->extensions()->size()); 608 extension = service->GetExtensionById(kExtensionId, false); 609 ASSERT_TRUE(extension); 610 EXPECT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD, extension->location()); 611 EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId)); 612 613 // Remove the policy, and verify that the extension was uninstalled. 614 // TODO(joaodasilva): it would be nicer if the extension was kept instead, 615 // and reverted location to INTERNAL or whatever it was before the policy 616 // was applied. 617 prefs->ClearPref(prefs::kExtensionInstallForceList); 618 ASSERT_EQ(size_before, service->extensions()->size()); 619 extension = service->GetExtensionById(kExtensionId, true); 620 EXPECT_FALSE(extension); 621 622 // User install again, but have it disabled too before setting the policy. 623 ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1)); 624 ASSERT_EQ(size_before + 1, service->extensions()->size()); 625 extension = service->GetExtensionById(kExtensionId, false); 626 ASSERT_TRUE(extension); 627 EXPECT_EQ(Manifest::INTERNAL, extension->location()); 628 EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId)); 629 EXPECT_TRUE(service->disabled_extensions()->is_empty()); 630 631 DisableExtension(kExtensionId); 632 EXPECT_EQ(1u, service->disabled_extensions()->size()); 633 extension = service->GetExtensionById(kExtensionId, true); 634 EXPECT_TRUE(extension); 635 EXPECT_FALSE(service->IsExtensionEnabled(kExtensionId)); 636 637 // Install the policy again. It should overwrite the extension's location, 638 // and force enable it too. 639 { 640 DictionaryPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList); 641 DictionaryValue* forcelist = pref_update.Get(); 642 extensions::ExternalPolicyLoader::AddExtension( 643 forcelist, kExtensionId, "http://localhost/autoupdate/manifest"); 644 } 645 ASSERT_TRUE(WaitForExtensionInstall()); 646 ASSERT_EQ(size_before + 1, service->extensions()->size()); 647 extension = service->GetExtensionById(kExtensionId, false); 648 ASSERT_TRUE(extension); 649 EXPECT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD, extension->location()); 650 EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId)); 651 EXPECT_TRUE(service->disabled_extensions()->is_empty()); 652} 653