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 "chrome/browser/custom_handlers/protocol_handler_registry.h" 6 7 #include <set> 8 9 #include "base/memory/scoped_ptr.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "base/synchronization/waitable_event.h" 13 #include "chrome/browser/chrome_notification_types.h" 14 #include "chrome/browser/prefs/pref_service_syncable.h" 15 #include "chrome/common/custom_handlers/protocol_handler.h" 16 #include "chrome/common/pref_names.h" 17 #include "chrome/test/base/testing_browser_process.h" 18 #include "chrome/test/base/testing_profile.h" 19 #include "components/pref_registry/pref_registry_syncable.h" 20 #include "content/public/browser/notification_observer.h" 21 #include "content/public/browser/notification_registrar.h" 22 #include "content/public/browser/notification_source.h" 23 #include "content/public/test/test_browser_thread.h" 24 #include "content/public/test/test_renderer_host.h" 25 #include "net/base/request_priority.h" 26 #include "net/url_request/url_request.h" 27 #include "net/url_request/url_request_context.h" 28 #include "testing/gtest/include/gtest/gtest.h" 29 30 using content::BrowserThread; 31 32 namespace { 33 34 void AssertInterceptedIO( 35 const GURL& url, 36 net::URLRequestJobFactory* interceptor) { 37 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 38 net::URLRequestContext context; 39 scoped_ptr<net::URLRequest> request(context.CreateRequest( 40 url, net::DEFAULT_PRIORITY, NULL, NULL)); 41 scoped_refptr<net::URLRequestJob> job = 42 interceptor->MaybeCreateJobWithProtocolHandler( 43 url.scheme(), request.get(), context.network_delegate()); 44 ASSERT_TRUE(job.get() != NULL); 45 } 46 47 void AssertIntercepted( 48 const GURL& url, 49 net::URLRequestJobFactory* interceptor) { 50 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 51 BrowserThread::PostTask(BrowserThread::IO, 52 FROM_HERE, 53 base::Bind(AssertInterceptedIO, 54 url, 55 base::Unretained(interceptor))); 56 base::MessageLoop::current()->RunUntilIdle(); 57 } 58 59 // FakeURLRequestJobFactory returns NULL for all job creation requests and false 60 // for all IsHandled*() requests. FakeURLRequestJobFactory can be chained to 61 // ProtocolHandlerRegistry::JobInterceptorFactory so the result of 62 // MaybeCreateJobWithProtocolHandler() indicates whether the 63 // ProtocolHandlerRegistry properly handled a job creation request. 64 class FakeURLRequestJobFactory : public net::URLRequestJobFactory { 65 // net::URLRequestJobFactory implementation: 66 virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler( 67 const std::string& scheme, 68 net::URLRequest* request, 69 net::NetworkDelegate* network_delegate) const OVERRIDE { 70 return NULL; 71 } 72 virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE { 73 return false; 74 } 75 virtual bool IsHandledURL(const GURL& url) const OVERRIDE { 76 return false; 77 } 78 virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE { 79 return true; 80 } 81 }; 82 83 void AssertWillHandleIO( 84 const std::string& scheme, 85 bool expected, 86 ProtocolHandlerRegistry::JobInterceptorFactory* interceptor) { 87 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 88 interceptor->Chain(scoped_ptr<net::URLRequestJobFactory>( 89 new FakeURLRequestJobFactory())); 90 ASSERT_EQ(expected, interceptor->IsHandledProtocol(scheme)); 91 interceptor->Chain(scoped_ptr<net::URLRequestJobFactory>()); 92 } 93 94 void AssertWillHandle( 95 const std::string& scheme, 96 bool expected, 97 ProtocolHandlerRegistry::JobInterceptorFactory* interceptor) { 98 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 99 BrowserThread::PostTask(BrowserThread::IO, 100 FROM_HERE, 101 base::Bind(AssertWillHandleIO, 102 scheme, 103 expected, 104 base::Unretained(interceptor))); 105 base::MessageLoop::current()->RunUntilIdle(); 106 } 107 108 base::DictionaryValue* GetProtocolHandlerValue(std::string protocol, 109 std::string url) { 110 base::DictionaryValue* value = new base::DictionaryValue(); 111 value->SetString("protocol", protocol); 112 value->SetString("url", url); 113 return value; 114 } 115 116 base::DictionaryValue* GetProtocolHandlerValueWithDefault(std::string protocol, 117 std::string url, 118 bool is_default) { 119 base::DictionaryValue* value = GetProtocolHandlerValue(protocol, url); 120 value->SetBoolean("default", is_default); 121 return value; 122 } 123 124 class FakeDelegate : public ProtocolHandlerRegistry::Delegate { 125 public: 126 FakeDelegate() : force_os_failure_(false) {} 127 virtual ~FakeDelegate() { } 128 virtual void RegisterExternalHandler(const std::string& protocol) OVERRIDE { 129 ASSERT_TRUE( 130 registered_protocols_.find(protocol) == registered_protocols_.end()); 131 registered_protocols_.insert(protocol); 132 } 133 134 virtual void DeregisterExternalHandler(const std::string& protocol) OVERRIDE { 135 registered_protocols_.erase(protocol); 136 } 137 138 virtual ShellIntegration::DefaultProtocolClientWorker* CreateShellWorker( 139 ShellIntegration::DefaultWebClientObserver* observer, 140 const std::string& protocol) OVERRIDE; 141 142 virtual ProtocolHandlerRegistry::DefaultClientObserver* CreateShellObserver( 143 ProtocolHandlerRegistry* registry) OVERRIDE; 144 145 virtual void RegisterWithOSAsDefaultClient( 146 const std::string& protocol, 147 ProtocolHandlerRegistry* reg) OVERRIDE { 148 ProtocolHandlerRegistry::Delegate::RegisterWithOSAsDefaultClient(protocol, 149 reg); 150 ASSERT_FALSE(IsFakeRegisteredWithOS(protocol)); 151 } 152 153 virtual bool IsExternalHandlerRegistered( 154 const std::string& protocol) OVERRIDE { 155 return registered_protocols_.find(protocol) != registered_protocols_.end(); 156 } 157 158 bool IsFakeRegisteredWithOS(const std::string& protocol) { 159 return os_registered_protocols_.find(protocol) != 160 os_registered_protocols_.end(); 161 } 162 163 void FakeRegisterWithOS(const std::string& protocol) { 164 os_registered_protocols_.insert(protocol); 165 } 166 167 void Reset() { 168 registered_protocols_.clear(); 169 os_registered_protocols_.clear(); 170 force_os_failure_ = false; 171 } 172 173 void set_force_os_failure(bool force) { force_os_failure_ = force; } 174 175 bool force_os_failure() { return force_os_failure_; } 176 177 private: 178 std::set<std::string> registered_protocols_; 179 std::set<std::string> os_registered_protocols_; 180 bool force_os_failure_; 181 }; 182 183 class FakeClientObserver 184 : public ProtocolHandlerRegistry::DefaultClientObserver { 185 public: 186 FakeClientObserver(ProtocolHandlerRegistry* registry, 187 FakeDelegate* registry_delegate) 188 : ProtocolHandlerRegistry::DefaultClientObserver(registry), 189 delegate_(registry_delegate) {} 190 191 virtual void SetDefaultWebClientUIState( 192 ShellIntegration::DefaultWebClientUIState state) OVERRIDE { 193 ProtocolHandlerRegistry::DefaultClientObserver::SetDefaultWebClientUIState( 194 state); 195 if (state == ShellIntegration::STATE_IS_DEFAULT) { 196 delegate_->FakeRegisterWithOS(worker_->protocol()); 197 } 198 if (state != ShellIntegration::STATE_PROCESSING) { 199 base::MessageLoop::current()->Quit(); 200 } 201 } 202 203 private: 204 FakeDelegate* delegate_; 205 }; 206 207 class FakeProtocolClientWorker 208 : public ShellIntegration::DefaultProtocolClientWorker { 209 public: 210 FakeProtocolClientWorker(ShellIntegration::DefaultWebClientObserver* observer, 211 const std::string& protocol, 212 bool force_failure) 213 : ShellIntegration::DefaultProtocolClientWorker(observer, protocol), 214 force_failure_(force_failure) {} 215 216 private: 217 virtual ~FakeProtocolClientWorker() {} 218 219 virtual ShellIntegration::DefaultWebClientState CheckIsDefault() OVERRIDE { 220 if (force_failure_) { 221 return ShellIntegration::NOT_DEFAULT; 222 } else { 223 return ShellIntegration::IS_DEFAULT; 224 } 225 } 226 227 virtual bool SetAsDefault(bool interactive_permitted) OVERRIDE { 228 return true; 229 } 230 231 private: 232 bool force_failure_; 233 }; 234 235 ProtocolHandlerRegistry::DefaultClientObserver* 236 FakeDelegate::CreateShellObserver(ProtocolHandlerRegistry* registry) { 237 return new FakeClientObserver(registry, this); 238 } 239 240 ShellIntegration::DefaultProtocolClientWorker* FakeDelegate::CreateShellWorker( 241 ShellIntegration::DefaultWebClientObserver* observer, 242 const std::string& protocol) { 243 return new FakeProtocolClientWorker(observer, protocol, force_os_failure_); 244 } 245 246 class NotificationCounter : public content::NotificationObserver { 247 public: 248 explicit NotificationCounter(content::BrowserContext* context) 249 : events_(0), 250 notification_registrar_() { 251 notification_registrar_.Add(this, 252 chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED, 253 content::Source<content::BrowserContext>(context)); 254 } 255 256 int events() { return events_; } 257 bool notified() { return events_ > 0; } 258 void Clear() { events_ = 0; } 259 virtual void Observe(int type, 260 const content::NotificationSource& source, 261 const content::NotificationDetails& details) OVERRIDE { 262 ++events_; 263 } 264 265 int events_; 266 content::NotificationRegistrar notification_registrar_; 267 }; 268 269 class QueryProtocolHandlerOnChange 270 : public content::NotificationObserver { 271 public: 272 QueryProtocolHandlerOnChange(content::BrowserContext* context, 273 ProtocolHandlerRegistry* registry) 274 : local_registry_(registry), 275 called_(false), 276 notification_registrar_() { 277 notification_registrar_.Add(this, 278 chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED, 279 content::Source<content::BrowserContext>(context)); 280 } 281 282 virtual void Observe(int type, 283 const content::NotificationSource& source, 284 const content::NotificationDetails& details) OVERRIDE { 285 std::vector<std::string> output; 286 local_registry_->GetRegisteredProtocols(&output); 287 called_ = true; 288 } 289 290 ProtocolHandlerRegistry* local_registry_; 291 bool called_; 292 content::NotificationRegistrar notification_registrar_; 293 }; 294 295 // URLRequest DCHECKS that the current MessageLoop is IO. It does this because 296 // it can't check the thread id (since net can't depend on content.) We want 297 // to harness our tests so all threads use the same loop allowing us to 298 // guarantee all messages are processed.) By overriding the IsType method 299 // we basically ignore the supplied message loop type, and instead infer 300 // our type based on the current thread. GO DEPENDENCY INJECTION! 301 class TestMessageLoop : public base::MessageLoop { 302 public: 303 TestMessageLoop() {} 304 virtual ~TestMessageLoop() {} 305 virtual bool IsType(base::MessageLoop::Type type) const OVERRIDE { 306 switch (type) { 307 case base::MessageLoop::TYPE_UI: 308 return BrowserThread::CurrentlyOn(BrowserThread::UI); 309 case base::MessageLoop::TYPE_IO: 310 return BrowserThread::CurrentlyOn(BrowserThread::IO); 311 #if defined(OS_ANDROID) 312 case base::MessageLoop::TYPE_JAVA: // fall-through 313 #endif // defined(OS_ANDROID) 314 case base::MessageLoop::TYPE_CUSTOM: 315 case base::MessageLoop::TYPE_DEFAULT: 316 return !BrowserThread::CurrentlyOn(BrowserThread::UI) && 317 !BrowserThread::CurrentlyOn(BrowserThread::IO); 318 } 319 return false; 320 } 321 }; 322 323 } // namespace 324 325 class ProtocolHandlerRegistryTest : public testing::Test { 326 protected: 327 ProtocolHandlerRegistryTest() 328 : ui_thread_(BrowserThread::UI, &loop_), 329 file_thread_(BrowserThread::FILE, &loop_), 330 io_thread_(BrowserThread::IO, &loop_), 331 test_protocol_handler_(CreateProtocolHandler("test", "test")) {} 332 333 FakeDelegate* delegate() const { return delegate_; } 334 ProtocolHandlerRegistry* registry() { return registry_.get(); } 335 TestingProfile* profile() const { return profile_.get(); } 336 const ProtocolHandler& test_protocol_handler() const { 337 return test_protocol_handler_; 338 } 339 340 ProtocolHandler CreateProtocolHandler(const std::string& protocol, 341 const GURL& url) { 342 return ProtocolHandler::CreateProtocolHandler(protocol, url); 343 } 344 345 ProtocolHandler CreateProtocolHandler(const std::string& protocol, 346 const std::string& name) { 347 return CreateProtocolHandler(protocol, GURL("http://" + name + "/%s")); 348 } 349 350 void RecreateRegistry(bool initialize) { 351 TeadDownRegistry(); 352 SetUpRegistry(initialize); 353 } 354 355 int InPrefHandlerCount() { 356 const base::ListValue* in_pref_handlers = 357 profile()->GetPrefs()->GetList(prefs::kRegisteredProtocolHandlers); 358 return static_cast<int>(in_pref_handlers->GetSize()); 359 } 360 361 int InMemoryHandlerCount() { 362 int in_memory_handler_count = 0; 363 ProtocolHandlerRegistry::ProtocolHandlerMultiMap::iterator it = 364 registry()->protocol_handlers_.begin(); 365 for (; it != registry()->protocol_handlers_.end(); ++it) 366 in_memory_handler_count += it->second.size(); 367 return in_memory_handler_count; 368 } 369 370 int InPrefIgnoredHandlerCount() { 371 const base::ListValue* in_pref_ignored_handlers = 372 profile()->GetPrefs()->GetList(prefs::kIgnoredProtocolHandlers); 373 return static_cast<int>(in_pref_ignored_handlers->GetSize()); 374 } 375 376 int InMemoryIgnoredHandlerCount() { 377 int in_memory_ignored_handler_count = 0; 378 ProtocolHandlerRegistry::ProtocolHandlerList::iterator it = 379 registry()->ignored_protocol_handlers_.begin(); 380 for (; it != registry()->ignored_protocol_handlers_.end(); ++it) 381 in_memory_ignored_handler_count++; 382 return in_memory_ignored_handler_count; 383 } 384 385 // Returns a new registry, initializing it if |initialize| is true. 386 // Caller assumes ownership for the object 387 void SetUpRegistry(bool initialize) { 388 delegate_ = new FakeDelegate(); 389 registry_.reset(new ProtocolHandlerRegistry(profile(), delegate())); 390 if (initialize) registry_->InitProtocolSettings(); 391 } 392 393 void TeadDownRegistry() { 394 registry_->Shutdown(); 395 registry_.reset(); 396 // Registry owns the delegate_ it handles deletion of that object. 397 } 398 399 virtual void SetUp() { 400 profile_.reset(new TestingProfile()); 401 CHECK(profile_->GetPrefs()); 402 SetUpRegistry(true); 403 test_protocol_handler_ = 404 CreateProtocolHandler("test", GURL("http://test.com/%s")); 405 } 406 407 virtual void TearDown() { 408 TeadDownRegistry(); 409 } 410 411 TestMessageLoop loop_; 412 413 private: 414 content::TestBrowserThread ui_thread_; 415 content::TestBrowserThread file_thread_; 416 content::TestBrowserThread io_thread_; 417 418 scoped_ptr<TestingProfile> profile_; 419 FakeDelegate* delegate_; // Registry assumes ownership of delegate_. 420 scoped_ptr<ProtocolHandlerRegistry> registry_; 421 ProtocolHandler test_protocol_handler_; 422 }; 423 424 // ProtocolHandlerRegistryTest tests are flaky on Linux & ChromeOS. 425 // http://crbug.com/133023 426 #if defined(OS_LINUX) 427 #define MAYBE_AcceptProtocolHandlerHandlesProtocol \ 428 DISABLED_AcceptProtocolHandlerHandlesProtocol 429 #define MAYBE_DeniedProtocolIsntHandledUntilAccepted \ 430 DISABLED_DeniedProtocolIsntHandledUntilAccepted 431 #define MAYBE_TestStartsAsDefault DISABLED_TestStartsAsDefault 432 #define MAYBE_TestRemoveHandlerRemovesDefault \ 433 DISABLED_TestRemoveHandlerRemovesDefault 434 #define MAYBE_TestClearDefaultGetsPropagatedToIO \ 435 DISABLED_TestClearDefaultGetsPropagatedToIO 436 #define MAYBE_TestIsHandledProtocolWorksOnIOThread \ 437 DISABLED_TestIsHandledProtocolWorksOnIOThread 438 #define MAYBE_TestInstallDefaultHandler \ 439 DISABLED_TestInstallDefaultHandler 440 #else 441 #define MAYBE_AcceptProtocolHandlerHandlesProtocol \ 442 AcceptProtocolHandlerHandlesProtocol 443 #define MAYBE_DeniedProtocolIsntHandledUntilAccepted \ 444 DeniedProtocolIsntHandledUntilAccepted 445 #define MAYBE_TestStartsAsDefault TestStartsAsDefault 446 #define MAYBE_TestRemoveHandlerRemovesDefault TestRemoveHandlerRemovesDefault 447 #define MAYBE_TestClearDefaultGetsPropagatedToIO \ 448 TestClearDefaultGetsPropagatedToIO 449 #define MAYBE_TestIsHandledProtocolWorksOnIOThread \ 450 TestIsHandledProtocolWorksOnIOThread 451 #define MAYBE_TestInstallDefaultHandler TestInstallDefaultHandler 452 #endif // defined(OS_LINUX) 453 454 TEST_F(ProtocolHandlerRegistryTest, 455 MAYBE_AcceptProtocolHandlerHandlesProtocol) { 456 ASSERT_FALSE(registry()->IsHandledProtocol("test")); 457 registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); 458 ASSERT_TRUE(registry()->IsHandledProtocol("test")); 459 } 460 461 TEST_F(ProtocolHandlerRegistryTest, 462 MAYBE_DeniedProtocolIsntHandledUntilAccepted) { 463 registry()->OnDenyRegisterProtocolHandler(test_protocol_handler()); 464 ASSERT_FALSE(registry()->IsHandledProtocol("test")); 465 registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); 466 ASSERT_TRUE(registry()->IsHandledProtocol("test")); 467 } 468 469 TEST_F(ProtocolHandlerRegistryTest, ClearDefaultMakesProtocolNotHandled) { 470 registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); 471 registry()->ClearDefault("test"); 472 ASSERT_FALSE(registry()->IsHandledProtocol("test")); 473 ASSERT_TRUE(registry()->GetHandlerFor("test").IsEmpty()); 474 } 475 476 TEST_F(ProtocolHandlerRegistryTest, DisableDeregistersProtocolHandlers) { 477 ASSERT_FALSE(delegate()->IsExternalHandlerRegistered("test")); 478 registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); 479 ASSERT_TRUE(delegate()->IsExternalHandlerRegistered("test")); 480 481 registry()->Disable(); 482 ASSERT_FALSE(delegate()->IsExternalHandlerRegistered("test")); 483 registry()->Enable(); 484 ASSERT_TRUE(delegate()->IsExternalHandlerRegistered("test")); 485 } 486 487 TEST_F(ProtocolHandlerRegistryTest, IgnoreProtocolHandler) { 488 registry()->OnIgnoreRegisterProtocolHandler(test_protocol_handler()); 489 ASSERT_TRUE(registry()->IsIgnored(test_protocol_handler())); 490 491 registry()->RemoveIgnoredHandler(test_protocol_handler()); 492 ASSERT_FALSE(registry()->IsIgnored(test_protocol_handler())); 493 } 494 495 TEST_F(ProtocolHandlerRegistryTest, IgnoreEquivalentProtocolHandler) { 496 ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s")); 497 ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s")); 498 499 registry()->OnIgnoreRegisterProtocolHandler(ph1); 500 ASSERT_TRUE(registry()->IsIgnored(ph1)); 501 ASSERT_TRUE(registry()->HasIgnoredEquivalent(ph2)); 502 503 registry()->RemoveIgnoredHandler(ph1); 504 ASSERT_FALSE(registry()->IsIgnored(ph1)); 505 ASSERT_FALSE(registry()->HasIgnoredEquivalent(ph2)); 506 } 507 508 TEST_F(ProtocolHandlerRegistryTest, SaveAndLoad) { 509 ProtocolHandler stuff_protocol_handler( 510 CreateProtocolHandler("stuff", "stuff")); 511 registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); 512 registry()->OnIgnoreRegisterProtocolHandler(stuff_protocol_handler); 513 514 ASSERT_TRUE(registry()->IsHandledProtocol("test")); 515 ASSERT_TRUE(registry()->IsIgnored(stuff_protocol_handler)); 516 delegate()->Reset(); 517 RecreateRegistry(true); 518 ASSERT_TRUE(registry()->IsHandledProtocol("test")); 519 ASSERT_TRUE(registry()->IsIgnored(stuff_protocol_handler)); 520 } 521 522 TEST_F(ProtocolHandlerRegistryTest, TestEnabledDisabled) { 523 registry()->Disable(); 524 ASSERT_FALSE(registry()->enabled()); 525 registry()->Enable(); 526 ASSERT_TRUE(registry()->enabled()); 527 } 528 529 TEST_F(ProtocolHandlerRegistryTest, 530 DisallowRegisteringExternallyHandledProtocols) { 531 delegate()->RegisterExternalHandler("test"); 532 ASSERT_FALSE(registry()->CanSchemeBeOverridden("test")); 533 } 534 535 TEST_F(ProtocolHandlerRegistryTest, RemovingHandlerMeansItCanBeAddedAgain) { 536 registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); 537 ASSERT_TRUE(registry()->CanSchemeBeOverridden("test")); 538 registry()->RemoveHandler(test_protocol_handler()); 539 ASSERT_TRUE(registry()->CanSchemeBeOverridden("test")); 540 } 541 542 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestStartsAsDefault) { 543 registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); 544 ASSERT_TRUE(registry()->IsDefault(test_protocol_handler())); 545 } 546 547 TEST_F(ProtocolHandlerRegistryTest, TestClearDefault) { 548 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 549 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 550 registry()->OnAcceptRegisterProtocolHandler(ph1); 551 registry()->OnAcceptRegisterProtocolHandler(ph2); 552 553 registry()->OnAcceptRegisterProtocolHandler(ph1); 554 registry()->ClearDefault("test"); 555 ASSERT_FALSE(registry()->IsDefault(ph1)); 556 ASSERT_FALSE(registry()->IsDefault(ph2)); 557 } 558 559 TEST_F(ProtocolHandlerRegistryTest, TestGetHandlerFor) { 560 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 561 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 562 registry()->OnAcceptRegisterProtocolHandler(ph1); 563 registry()->OnAcceptRegisterProtocolHandler(ph2); 564 565 registry()->OnAcceptRegisterProtocolHandler(ph2); 566 ASSERT_EQ(ph2, registry()->GetHandlerFor("test")); 567 ASSERT_TRUE(registry()->IsHandledProtocol("test")); 568 } 569 570 TEST_F(ProtocolHandlerRegistryTest, TestMostRecentHandlerIsDefault) { 571 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 572 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 573 registry()->OnAcceptRegisterProtocolHandler(ph1); 574 registry()->OnAcceptRegisterProtocolHandler(ph2); 575 ASSERT_FALSE(registry()->IsDefault(ph1)); 576 ASSERT_TRUE(registry()->IsDefault(ph2)); 577 } 578 579 TEST_F(ProtocolHandlerRegistryTest, TestOnAcceptRegisterProtocolHandler) { 580 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 581 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 582 registry()->OnAcceptRegisterProtocolHandler(ph1); 583 registry()->OnAcceptRegisterProtocolHandler(ph2); 584 585 registry()->OnAcceptRegisterProtocolHandler(ph1); 586 ASSERT_TRUE(registry()->IsDefault(ph1)); 587 ASSERT_FALSE(registry()->IsDefault(ph2)); 588 589 registry()->OnAcceptRegisterProtocolHandler(ph2); 590 ASSERT_FALSE(registry()->IsDefault(ph1)); 591 ASSERT_TRUE(registry()->IsDefault(ph2)); 592 } 593 594 TEST_F(ProtocolHandlerRegistryTest, TestDefaultSaveLoad) { 595 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 596 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 597 registry()->OnDenyRegisterProtocolHandler(ph1); 598 registry()->OnDenyRegisterProtocolHandler(ph2); 599 600 registry()->OnAcceptRegisterProtocolHandler(ph2); 601 registry()->Disable(); 602 603 RecreateRegistry(true); 604 605 ASSERT_FALSE(registry()->enabled()); 606 registry()->Enable(); 607 ASSERT_FALSE(registry()->IsDefault(ph1)); 608 ASSERT_TRUE(registry()->IsDefault(ph2)); 609 610 RecreateRegistry(true); 611 ASSERT_TRUE(registry()->enabled()); 612 } 613 614 TEST_F(ProtocolHandlerRegistryTest, TestRemoveHandler) { 615 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 616 registry()->OnAcceptRegisterProtocolHandler(ph1); 617 registry()->OnAcceptRegisterProtocolHandler(ph1); 618 619 registry()->RemoveHandler(ph1); 620 ASSERT_FALSE(registry()->IsRegistered(ph1)); 621 ASSERT_FALSE(registry()->IsHandledProtocol("test")); 622 } 623 624 TEST_F(ProtocolHandlerRegistryTest, TestIsRegistered) { 625 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 626 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 627 registry()->OnAcceptRegisterProtocolHandler(ph1); 628 registry()->OnAcceptRegisterProtocolHandler(ph2); 629 630 ASSERT_TRUE(registry()->IsRegistered(ph1)); 631 } 632 633 TEST_F(ProtocolHandlerRegistryTest, TestIsEquivalentRegistered) { 634 ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s")); 635 ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s")); 636 registry()->OnAcceptRegisterProtocolHandler(ph1); 637 638 ASSERT_TRUE(registry()->IsRegistered(ph1)); 639 ASSERT_TRUE(registry()->HasRegisteredEquivalent(ph2)); 640 } 641 642 TEST_F(ProtocolHandlerRegistryTest, TestSilentlyRegisterHandler) { 643 ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/1/%s")); 644 ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/2/%s")); 645 ProtocolHandler ph3 = CreateProtocolHandler("ignore", GURL("http://test/%s")); 646 ProtocolHandler ph4 = CreateProtocolHandler("ignore", GURL("http://test/%s")); 647 648 ASSERT_FALSE(registry()->SilentlyHandleRegisterHandlerRequest(ph1)); 649 ASSERT_FALSE(registry()->IsRegistered(ph1)); 650 651 registry()->OnAcceptRegisterProtocolHandler(ph1); 652 ASSERT_TRUE(registry()->IsRegistered(ph1)); 653 654 ASSERT_TRUE(registry()->SilentlyHandleRegisterHandlerRequest(ph2)); 655 ASSERT_FALSE(registry()->IsRegistered(ph1)); 656 ASSERT_TRUE(registry()->IsRegistered(ph2)); 657 658 ASSERT_FALSE(registry()->SilentlyHandleRegisterHandlerRequest(ph3)); 659 ASSERT_FALSE(registry()->IsRegistered(ph3)); 660 661 registry()->OnIgnoreRegisterProtocolHandler(ph3); 662 ASSERT_FALSE(registry()->IsRegistered(ph3)); 663 ASSERT_TRUE(registry()->IsIgnored(ph3)); 664 665 ASSERT_TRUE(registry()->SilentlyHandleRegisterHandlerRequest(ph4)); 666 ASSERT_FALSE(registry()->IsRegistered(ph4)); 667 ASSERT_TRUE(registry()->HasIgnoredEquivalent(ph4)); 668 } 669 670 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestRemoveHandlerRemovesDefault) { 671 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 672 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 673 ProtocolHandler ph3 = CreateProtocolHandler("test", "test3"); 674 675 registry()->OnAcceptRegisterProtocolHandler(ph1); 676 registry()->OnAcceptRegisterProtocolHandler(ph2); 677 registry()->OnAcceptRegisterProtocolHandler(ph3); 678 679 registry()->OnAcceptRegisterProtocolHandler(ph1); 680 registry()->RemoveHandler(ph1); 681 ASSERT_FALSE(registry()->IsDefault(ph1)); 682 } 683 684 TEST_F(ProtocolHandlerRegistryTest, TestGetHandlersFor) { 685 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 686 ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); 687 ProtocolHandler ph3 = CreateProtocolHandler("test", "test3"); 688 registry()->OnAcceptRegisterProtocolHandler(ph1); 689 registry()->OnAcceptRegisterProtocolHandler(ph2); 690 registry()->OnAcceptRegisterProtocolHandler(ph3); 691 692 ProtocolHandlerRegistry::ProtocolHandlerList handlers = 693 registry()->GetHandlersFor("test"); 694 ASSERT_EQ(static_cast<size_t>(3), handlers.size()); 695 696 ASSERT_EQ(ph3, handlers[0]); 697 ASSERT_EQ(ph2, handlers[1]); 698 ASSERT_EQ(ph1, handlers[2]); 699 } 700 701 TEST_F(ProtocolHandlerRegistryTest, TestGetRegisteredProtocols) { 702 std::vector<std::string> protocols; 703 registry()->GetRegisteredProtocols(&protocols); 704 ASSERT_EQ(static_cast<size_t>(0), protocols.size()); 705 706 registry()->GetHandlersFor("test"); 707 708 protocols.clear(); 709 registry()->GetRegisteredProtocols(&protocols); 710 ASSERT_EQ(static_cast<size_t>(0), protocols.size()); 711 } 712 713 TEST_F(ProtocolHandlerRegistryTest, TestIsHandledProtocol) { 714 registry()->GetHandlersFor("test"); 715 ASSERT_FALSE(registry()->IsHandledProtocol("test")); 716 } 717 718 TEST_F(ProtocolHandlerRegistryTest, TestNotifications) { 719 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 720 NotificationCounter counter(profile()); 721 722 registry()->OnAcceptRegisterProtocolHandler(ph1); 723 ASSERT_TRUE(counter.notified()); 724 counter.Clear(); 725 726 registry()->Disable(); 727 ASSERT_TRUE(counter.notified()); 728 counter.Clear(); 729 730 registry()->Enable(); 731 ASSERT_TRUE(counter.notified()); 732 counter.Clear(); 733 734 registry()->RemoveHandler(ph1); 735 ASSERT_TRUE(counter.notified()); 736 counter.Clear(); 737 } 738 739 TEST_F(ProtocolHandlerRegistryTest, TestReentrantNotifications) { 740 QueryProtocolHandlerOnChange queryer(profile(), registry()); 741 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 742 registry()->OnAcceptRegisterProtocolHandler(ph1); 743 ASSERT_TRUE(queryer.called_); 744 } 745 746 TEST_F(ProtocolHandlerRegistryTest, TestProtocolsWithNoDefaultAreHandled) { 747 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 748 registry()->OnAcceptRegisterProtocolHandler(ph1); 749 registry()->ClearDefault("test"); 750 std::vector<std::string> handled_protocols; 751 registry()->GetRegisteredProtocols(&handled_protocols); 752 ASSERT_EQ(static_cast<size_t>(1), handled_protocols.size()); 753 ASSERT_EQ("test", handled_protocols[0]); 754 } 755 756 TEST_F(ProtocolHandlerRegistryTest, TestDisablePreventsHandling) { 757 ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); 758 registry()->OnAcceptRegisterProtocolHandler(ph1); 759 ASSERT_TRUE(registry()->IsHandledProtocol("test")); 760 registry()->Disable(); 761 ASSERT_FALSE(registry()->IsHandledProtocol("test")); 762 } 763 764 // TODO(smckay): This is much more appropriately an integration 765 // test. Make that so, then update the 766 // ShellIntegretion{Delegate,Observer,Worker} test classes we use to fully 767 // isolate this test from the FILE thread. 768 TEST_F(ProtocolHandlerRegistryTest, TestOSRegistration) { 769 ProtocolHandler ph_do1 = CreateProtocolHandler("do", "test1"); 770 ProtocolHandler ph_do2 = CreateProtocolHandler("do", "test2"); 771 ProtocolHandler ph_dont = CreateProtocolHandler("dont", "test"); 772 773 ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("do")); 774 ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("dont")); 775 776 registry()->OnAcceptRegisterProtocolHandler(ph_do1); 777 registry()->OnDenyRegisterProtocolHandler(ph_dont); 778 base::MessageLoop::current()->Run(); // FILE thread needs to run. 779 ASSERT_TRUE(delegate()->IsFakeRegisteredWithOS("do")); 780 ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("dont")); 781 782 // This should not register with the OS, if it does the delegate 783 // will assert for us. We don't need to wait for the message loop 784 // as it should not go through to the shell worker. 785 registry()->OnAcceptRegisterProtocolHandler(ph_do2); 786 } 787 788 #if defined(OS_LINUX) 789 // TODO(benwells): When Linux support is more reliable and 790 // http://crbut.com/88255 is fixed this test will pass. 791 #define MAYBE_TestOSRegistrationFailure DISABLED_TestOSRegistrationFailure 792 #else 793 #define MAYBE_TestOSRegistrationFailure TestOSRegistrationFailure 794 #endif 795 796 // TODO(smckay): This is much more appropriately an integration 797 // test. Make that so, then update the 798 // ShellIntegretion{Delegate,Observer,Worker} test classes we use to fully 799 // isolate this test from the FILE thread. 800 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestOSRegistrationFailure) { 801 ProtocolHandler ph_do = CreateProtocolHandler("do", "test1"); 802 ProtocolHandler ph_dont = CreateProtocolHandler("dont", "test"); 803 804 ASSERT_FALSE(registry()->IsHandledProtocol("do")); 805 ASSERT_FALSE(registry()->IsHandledProtocol("dont")); 806 807 registry()->OnAcceptRegisterProtocolHandler(ph_do); 808 base::MessageLoop::current()->Run(); // FILE thread needs to run. 809 delegate()->set_force_os_failure(true); 810 registry()->OnAcceptRegisterProtocolHandler(ph_dont); 811 base::MessageLoop::current()->Run(); // FILE thread needs to run. 812 ASSERT_TRUE(registry()->IsHandledProtocol("do")); 813 ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("do").size()); 814 ASSERT_FALSE(registry()->IsHandledProtocol("dont")); 815 ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("dont").size()); 816 } 817 818 TEST_F(ProtocolHandlerRegistryTest, TestMaybeCreateTaskWorksFromIOThread) { 819 ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1"); 820 registry()->OnAcceptRegisterProtocolHandler(ph1); 821 GURL url("mailto:someone (at) something.com"); 822 823 scoped_ptr<net::URLRequestJobFactory> interceptor( 824 registry()->CreateJobInterceptorFactory()); 825 AssertIntercepted(url, interceptor.get()); 826 } 827 828 TEST_F(ProtocolHandlerRegistryTest, 829 MAYBE_TestIsHandledProtocolWorksOnIOThread) { 830 std::string scheme("mailto"); 831 ProtocolHandler ph1 = CreateProtocolHandler(scheme, "test1"); 832 registry()->OnAcceptRegisterProtocolHandler(ph1); 833 834 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor( 835 registry()->CreateJobInterceptorFactory()); 836 AssertWillHandle(scheme, true, interceptor.get()); 837 } 838 839 TEST_F(ProtocolHandlerRegistryTest, TestRemovingDefaultFallsBackToOldDefault) { 840 ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1"); 841 ProtocolHandler ph2 = CreateProtocolHandler("mailto", "test2"); 842 ProtocolHandler ph3 = CreateProtocolHandler("mailto", "test3"); 843 registry()->OnAcceptRegisterProtocolHandler(ph1); 844 registry()->OnAcceptRegisterProtocolHandler(ph2); 845 registry()->OnAcceptRegisterProtocolHandler(ph3); 846 847 ASSERT_TRUE(registry()->IsDefault(ph3)); 848 registry()->RemoveHandler(ph3); 849 ASSERT_TRUE(registry()->IsDefault(ph2)); 850 registry()->OnAcceptRegisterProtocolHandler(ph3); 851 ASSERT_TRUE(registry()->IsDefault(ph3)); 852 registry()->RemoveHandler(ph2); 853 ASSERT_TRUE(registry()->IsDefault(ph3)); 854 registry()->RemoveHandler(ph3); 855 ASSERT_TRUE(registry()->IsDefault(ph1)); 856 } 857 858 TEST_F(ProtocolHandlerRegistryTest, TestRemovingDefaultDoesntChangeHandlers) { 859 ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1"); 860 ProtocolHandler ph2 = CreateProtocolHandler("mailto", "test2"); 861 ProtocolHandler ph3 = CreateProtocolHandler("mailto", "test3"); 862 registry()->OnAcceptRegisterProtocolHandler(ph1); 863 registry()->OnAcceptRegisterProtocolHandler(ph2); 864 registry()->OnAcceptRegisterProtocolHandler(ph3); 865 registry()->RemoveHandler(ph3); 866 867 ProtocolHandlerRegistry::ProtocolHandlerList handlers = 868 registry()->GetHandlersFor("mailto"); 869 ASSERT_EQ(static_cast<size_t>(2), handlers.size()); 870 871 ASSERT_EQ(ph2, handlers[0]); 872 ASSERT_EQ(ph1, handlers[1]); 873 } 874 875 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestClearDefaultGetsPropagatedToIO) { 876 std::string scheme("mailto"); 877 ProtocolHandler ph1 = CreateProtocolHandler(scheme, "test1"); 878 registry()->OnAcceptRegisterProtocolHandler(ph1); 879 registry()->ClearDefault(scheme); 880 881 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor( 882 registry()->CreateJobInterceptorFactory()); 883 AssertWillHandle(scheme, false, interceptor.get()); 884 } 885 886 TEST_F(ProtocolHandlerRegistryTest, TestLoadEnabledGetsPropogatedToIO) { 887 std::string mailto("mailto"); 888 ProtocolHandler ph1 = CreateProtocolHandler(mailto, "MailtoHandler"); 889 registry()->OnAcceptRegisterProtocolHandler(ph1); 890 891 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor( 892 registry()->CreateJobInterceptorFactory()); 893 AssertWillHandle(mailto, true, interceptor.get()); 894 registry()->Disable(); 895 AssertWillHandle(mailto, false, interceptor.get()); 896 } 897 898 TEST_F(ProtocolHandlerRegistryTest, TestReplaceHandler) { 899 ProtocolHandler ph1 = 900 CreateProtocolHandler("mailto", GURL("http://test.com/%s")); 901 ProtocolHandler ph2 = 902 CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); 903 registry()->OnAcceptRegisterProtocolHandler(ph1); 904 ASSERT_TRUE(registry()->AttemptReplace(ph2)); 905 const ProtocolHandler& handler(registry()->GetHandlerFor("mailto")); 906 ASSERT_EQ(handler.url(), ph2.url()); 907 } 908 909 TEST_F(ProtocolHandlerRegistryTest, TestReplaceNonDefaultHandler) { 910 ProtocolHandler ph1 = 911 CreateProtocolHandler("mailto", GURL("http://test.com/%s")); 912 ProtocolHandler ph2 = 913 CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); 914 ProtocolHandler ph3 = 915 CreateProtocolHandler("mailto", GURL("http://else.com/%s")); 916 registry()->OnAcceptRegisterProtocolHandler(ph1); 917 registry()->OnAcceptRegisterProtocolHandler(ph3); 918 ASSERT_TRUE(registry()->AttemptReplace(ph2)); 919 const ProtocolHandler& handler(registry()->GetHandlerFor("mailto")); 920 ASSERT_EQ(handler.url(), ph3.url()); 921 } 922 923 TEST_F(ProtocolHandlerRegistryTest, TestReplaceRemovesStaleHandlers) { 924 ProtocolHandler ph1 = 925 CreateProtocolHandler("mailto", GURL("http://test.com/%s")); 926 ProtocolHandler ph2 = 927 CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); 928 ProtocolHandler ph3 = 929 CreateProtocolHandler("mailto", GURL("http://test.com/third/%s")); 930 registry()->OnAcceptRegisterProtocolHandler(ph1); 931 registry()->OnAcceptRegisterProtocolHandler(ph2); 932 933 // This should replace the previous two handlers. 934 ASSERT_TRUE(registry()->AttemptReplace(ph3)); 935 const ProtocolHandler& handler(registry()->GetHandlerFor("mailto")); 936 ASSERT_EQ(handler.url(), ph3.url()); 937 registry()->RemoveHandler(ph3); 938 ASSERT_TRUE(registry()->GetHandlerFor("mailto").IsEmpty()); 939 } 940 941 TEST_F(ProtocolHandlerRegistryTest, TestIsSameOrigin) { 942 ProtocolHandler ph1 = 943 CreateProtocolHandler("mailto", GURL("http://test.com/%s")); 944 ProtocolHandler ph2 = 945 CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); 946 ProtocolHandler ph3 = 947 CreateProtocolHandler("mailto", GURL("http://other.com/%s")); 948 ASSERT_EQ(ph1.url().GetOrigin() == ph2.url().GetOrigin(), 949 ph1.IsSameOrigin(ph2)); 950 ASSERT_EQ(ph1.url().GetOrigin() == ph2.url().GetOrigin(), 951 ph2.IsSameOrigin(ph1)); 952 ASSERT_EQ(ph2.url().GetOrigin() == ph3.url().GetOrigin(), 953 ph2.IsSameOrigin(ph3)); 954 ASSERT_EQ(ph3.url().GetOrigin() == ph2.url().GetOrigin(), 955 ph3.IsSameOrigin(ph2)); 956 } 957 958 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestInstallDefaultHandler) { 959 RecreateRegistry(false); 960 registry()->AddPredefinedHandler( 961 CreateProtocolHandler("test", GURL("http://test.com/%s"))); 962 registry()->InitProtocolSettings(); 963 std::vector<std::string> protocols; 964 registry()->GetRegisteredProtocols(&protocols); 965 ASSERT_EQ(static_cast<size_t>(1), protocols.size()); 966 } 967 968 #define URL_p1u1 "http://p1u1.com/%s" 969 #define URL_p1u2 "http://p1u2.com/%s" 970 #define URL_p1u3 "http://p1u3.com/%s" 971 #define URL_p2u1 "http://p2u1.com/%s" 972 #define URL_p2u2 "http://p2u2.com/%s" 973 #define URL_p3u1 "http://p3u1.com/%s" 974 975 TEST_F(ProtocolHandlerRegistryTest, TestPrefPolicyOverlapRegister) { 976 base::ListValue handlers_registered_by_pref; 977 base::ListValue handlers_registered_by_policy; 978 979 handlers_registered_by_pref.Append( 980 GetProtocolHandlerValueWithDefault("p1", URL_p1u2, true)); 981 handlers_registered_by_pref.Append( 982 GetProtocolHandlerValueWithDefault("p1", URL_p1u1, true)); 983 handlers_registered_by_pref.Append( 984 GetProtocolHandlerValueWithDefault("p1", URL_p1u2, false)); 985 986 handlers_registered_by_policy.Append( 987 GetProtocolHandlerValueWithDefault("p1", URL_p1u1, false)); 988 handlers_registered_by_policy.Append( 989 GetProtocolHandlerValueWithDefault("p3", URL_p3u1, true)); 990 991 profile()->GetPrefs()->Set(prefs::kRegisteredProtocolHandlers, 992 handlers_registered_by_pref); 993 profile()->GetPrefs()->Set(prefs::kPolicyRegisteredProtocolHandlers, 994 handlers_registered_by_policy); 995 registry()->InitProtocolSettings(); 996 997 // Duplicate p1u2 eliminated in memory but not yet saved in pref 998 ProtocolHandler p1u1 = CreateProtocolHandler("p1", GURL(URL_p1u1)); 999 ProtocolHandler p1u2 = CreateProtocolHandler("p1", GURL(URL_p1u2)); 1000 ASSERT_EQ(InPrefHandlerCount(), 3); 1001 ASSERT_EQ(InMemoryHandlerCount(), 3); 1002 ASSERT_TRUE(registry()->IsDefault(p1u1)); 1003 ASSERT_FALSE(registry()->IsDefault(p1u2)); 1004 1005 ProtocolHandler p2u1 = CreateProtocolHandler("p2", GURL(URL_p2u1)); 1006 registry()->OnDenyRegisterProtocolHandler(p2u1); 1007 1008 // Duplicate p1u2 saved in pref and a new handler added to pref and memory 1009 ASSERT_EQ(InPrefHandlerCount(), 3); 1010 ASSERT_EQ(InMemoryHandlerCount(), 4); 1011 ASSERT_FALSE(registry()->IsDefault(p2u1)); 1012 1013 registry()->RemoveHandler(p1u1); 1014 1015 // p1u1 removed from user pref but not from memory due to policy. 1016 ASSERT_EQ(InPrefHandlerCount(), 2); 1017 ASSERT_EQ(InMemoryHandlerCount(), 4); 1018 ASSERT_TRUE(registry()->IsDefault(p1u1)); 1019 1020 ProtocolHandler p3u1 = CreateProtocolHandler("p3", GURL(URL_p3u1)); 1021 registry()->RemoveHandler(p3u1); 1022 1023 // p3u1 not removed from memory due to policy and it was never in pref. 1024 ASSERT_EQ(InPrefHandlerCount(), 2); 1025 ASSERT_EQ(InMemoryHandlerCount(), 4); 1026 ASSERT_TRUE(registry()->IsDefault(p3u1)); 1027 1028 registry()->RemoveHandler(p1u2); 1029 1030 // p1u2 removed from user pref and memory. 1031 ASSERT_EQ(InPrefHandlerCount(), 1); 1032 ASSERT_EQ(InMemoryHandlerCount(), 3); 1033 ASSERT_TRUE(registry()->IsDefault(p1u1)); 1034 1035 ProtocolHandler p1u3 = CreateProtocolHandler("p1", GURL(URL_p1u3)); 1036 registry()->OnAcceptRegisterProtocolHandler(p1u3); 1037 1038 // p1u3 added to pref and memory. 1039 ASSERT_EQ(InPrefHandlerCount(), 2); 1040 ASSERT_EQ(InMemoryHandlerCount(), 4); 1041 ASSERT_FALSE(registry()->IsDefault(p1u1)); 1042 ASSERT_TRUE(registry()->IsDefault(p1u3)); 1043 1044 registry()->RemoveHandler(p1u3); 1045 1046 // p1u3 the default handler for p1 removed from user pref and memory. 1047 ASSERT_EQ(InPrefHandlerCount(), 1); 1048 ASSERT_EQ(InMemoryHandlerCount(), 3); 1049 ASSERT_FALSE(registry()->IsDefault(p1u3)); 1050 ASSERT_TRUE(registry()->IsDefault(p1u1)); 1051 ASSERT_TRUE(registry()->IsDefault(p3u1)); 1052 ASSERT_FALSE(registry()->IsDefault(p2u1)); 1053 } 1054 1055 TEST_F(ProtocolHandlerRegistryTest, TestPrefPolicyOverlapIgnore) { 1056 base::ListValue handlers_ignored_by_pref; 1057 base::ListValue handlers_ignored_by_policy; 1058 1059 handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p1", URL_p1u1)); 1060 handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p1", URL_p1u2)); 1061 handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p1", URL_p1u2)); 1062 handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p3", URL_p3u1)); 1063 1064 handlers_ignored_by_policy.Append(GetProtocolHandlerValue("p1", URL_p1u2)); 1065 handlers_ignored_by_policy.Append(GetProtocolHandlerValue("p1", URL_p1u3)); 1066 handlers_ignored_by_policy.Append(GetProtocolHandlerValue("p2", URL_p2u1)); 1067 1068 profile()->GetPrefs()->Set(prefs::kIgnoredProtocolHandlers, 1069 handlers_ignored_by_pref); 1070 profile()->GetPrefs()->Set(prefs::kPolicyIgnoredProtocolHandlers, 1071 handlers_ignored_by_policy); 1072 registry()->InitProtocolSettings(); 1073 1074 // Duplicate p1u2 eliminated in memory but not yet saved in pref 1075 ASSERT_EQ(InPrefIgnoredHandlerCount(), 4); 1076 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 5); 1077 1078 ProtocolHandler p2u2 = CreateProtocolHandler("p2", GURL(URL_p2u2)); 1079 registry()->OnIgnoreRegisterProtocolHandler(p2u2); 1080 1081 // Duplicate p1u2 eliminated in pref, p2u2 added to pref and memory. 1082 ASSERT_EQ(InPrefIgnoredHandlerCount(), 4); 1083 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 6); 1084 1085 ProtocolHandler p2u1 = CreateProtocolHandler("p2", GURL(URL_p2u1)); 1086 registry()->RemoveIgnoredHandler(p2u1); 1087 1088 // p2u1 installed by policy so cant be removed. 1089 ASSERT_EQ(InPrefIgnoredHandlerCount(), 4); 1090 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 6); 1091 1092 ProtocolHandler p1u2 = CreateProtocolHandler("p1", GURL(URL_p1u2)); 1093 registry()->RemoveIgnoredHandler(p1u2); 1094 1095 // p1u2 installed by policy and pref so it is removed from pref and not from 1096 // memory. 1097 ASSERT_EQ(InPrefIgnoredHandlerCount(), 3); 1098 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 6); 1099 1100 ProtocolHandler p1u1 = CreateProtocolHandler("p1", GURL(URL_p1u1)); 1101 registry()->RemoveIgnoredHandler(p1u1); 1102 1103 // p1u1 installed by pref so it is removed from pref and memory. 1104 ASSERT_EQ(InPrefIgnoredHandlerCount(), 2); 1105 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 5); 1106 1107 registry()->RemoveIgnoredHandler(p2u2); 1108 1109 // p2u2 installed by user so it is removed from pref and memory. 1110 ASSERT_EQ(InPrefIgnoredHandlerCount(), 1); 1111 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4); 1112 1113 registry()->OnIgnoreRegisterProtocolHandler(p2u1); 1114 1115 // p2u1 installed by user but it is already installed by policy, so it is 1116 // added to pref. 1117 ASSERT_EQ(InPrefIgnoredHandlerCount(), 2); 1118 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4); 1119 1120 registry()->RemoveIgnoredHandler(p2u1); 1121 1122 // p2u1 installed by user and policy, so it is removed from pref alone. 1123 ASSERT_EQ(InPrefIgnoredHandlerCount(), 1); 1124 ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4); 1125 } 1126