| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/custom_handlers/protocol_handler_registry.h" |
| |
| #include <stddef.h> |
| |
| #include <memory> |
| #include <set> |
| |
| #include "base/memory/ptr_util.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/run_loop.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/chrome_notification_types.h" |
| #include "chrome/common/custom_handlers/protocol_handler.h" |
| #include "chrome/common/pref_names.h" |
| #include "chrome/test/base/testing_browser_process.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "components/pref_registry/pref_registry_syncable.h" |
| #include "components/syncable_prefs/pref_service_syncable.h" |
| #include "content/public/browser/notification_observer.h" |
| #include "content/public/browser/notification_registrar.h" |
| #include "content/public/browser/notification_source.h" |
| #include "content/public/test/test_browser_thread.h" |
| #include "content/public/test/test_renderer_host.h" |
| #include "net/base/request_priority.h" |
| #include "net/url_request/url_request.h" |
| #include "net/url_request/url_request_context.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using content::BrowserThread; |
| |
| namespace { |
| |
| void AssertInterceptedIO( |
| const GURL& url, |
| net::URLRequestJobFactory* interceptor) { |
| DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| net::URLRequestContext context; |
| std::unique_ptr<net::URLRequest> request( |
| context.CreateRequest(url, net::DEFAULT_PRIORITY, nullptr)); |
| std::unique_ptr<net::URLRequestJob> job( |
| interceptor->MaybeCreateJobWithProtocolHandler( |
| url.scheme(), request.get(), context.network_delegate())); |
| ASSERT_TRUE(job.get()); |
| } |
| |
| void AssertIntercepted( |
| const GURL& url, |
| net::URLRequestJobFactory* interceptor) { |
| DCHECK_CURRENTLY_ON(BrowserThread::UI); |
| BrowserThread::PostTask(BrowserThread::IO, |
| FROM_HERE, |
| base::Bind(AssertInterceptedIO, |
| url, |
| base::Unretained(interceptor))); |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| // FakeURLRequestJobFactory returns NULL for all job creation requests and false |
| // for all IsHandled*() requests. FakeURLRequestJobFactory can be chained to |
| // ProtocolHandlerRegistry::JobInterceptorFactory so the result of |
| // MaybeCreateJobWithProtocolHandler() indicates whether the |
| // ProtocolHandlerRegistry properly handled a job creation request. |
| class FakeURLRequestJobFactory : public net::URLRequestJobFactory { |
| // net::URLRequestJobFactory implementation: |
| net::URLRequestJob* MaybeCreateJobWithProtocolHandler( |
| const std::string& scheme, |
| net::URLRequest* request, |
| net::NetworkDelegate* network_delegate) const override { |
| return NULL; |
| } |
| |
| net::URLRequestJob* MaybeInterceptRedirect( |
| net::URLRequest* request, |
| net::NetworkDelegate* network_delegate, |
| const GURL& location) const override { |
| return nullptr; |
| } |
| |
| net::URLRequestJob* MaybeInterceptResponse( |
| net::URLRequest* request, |
| net::NetworkDelegate* network_delegate) const override { |
| return nullptr; |
| } |
| |
| bool IsHandledProtocol(const std::string& scheme) const override { |
| return false; |
| } |
| bool IsHandledURL(const GURL& url) const override { return false; } |
| bool IsSafeRedirectTarget(const GURL& location) const override { |
| return true; |
| } |
| }; |
| |
| void AssertWillHandleIO( |
| const std::string& scheme, |
| bool expected, |
| ProtocolHandlerRegistry::JobInterceptorFactory* interceptor) { |
| DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| interceptor->Chain(std::unique_ptr<net::URLRequestJobFactory>( |
| new FakeURLRequestJobFactory())); |
| ASSERT_EQ(expected, interceptor->IsHandledProtocol(scheme)); |
| interceptor->Chain(std::unique_ptr<net::URLRequestJobFactory>()); |
| } |
| |
| void AssertWillHandle( |
| const std::string& scheme, |
| bool expected, |
| ProtocolHandlerRegistry::JobInterceptorFactory* interceptor) { |
| DCHECK_CURRENTLY_ON(BrowserThread::UI); |
| BrowserThread::PostTask(BrowserThread::IO, |
| FROM_HERE, |
| base::Bind(AssertWillHandleIO, |
| scheme, |
| expected, |
| base::Unretained(interceptor))); |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| std::unique_ptr<base::DictionaryValue> GetProtocolHandlerValue( |
| const std::string& protocol, |
| const std::string& url) { |
| auto value = base::MakeUnique<base::DictionaryValue>(); |
| value->SetString("protocol", protocol); |
| value->SetString("url", url); |
| return value; |
| } |
| |
| std::unique_ptr<base::DictionaryValue> GetProtocolHandlerValueWithDefault( |
| const std::string& protocol, |
| const std::string& url, |
| bool is_default) { |
| std::unique_ptr<base::DictionaryValue> value = |
| GetProtocolHandlerValue(protocol, url); |
| value->SetBoolean("default", is_default); |
| return value; |
| } |
| |
| class FakeProtocolClientWorker |
| : public shell_integration::DefaultProtocolClientWorker { |
| public: |
| FakeProtocolClientWorker( |
| const shell_integration::DefaultWebClientWorkerCallback& callback, |
| const std::string& protocol, |
| bool force_failure) |
| : shell_integration::DefaultProtocolClientWorker(callback, protocol), |
| force_failure_(force_failure) {} |
| |
| private: |
| ~FakeProtocolClientWorker() override = default; |
| |
| shell_integration::DefaultWebClientState CheckIsDefaultImpl() override { |
| return force_failure_ ? shell_integration::NOT_DEFAULT |
| : shell_integration::IS_DEFAULT; |
| } |
| |
| void SetAsDefaultImpl(const base::Closure& on_finished_callback) override { |
| on_finished_callback.Run(); |
| } |
| |
| private: |
| bool force_failure_; |
| }; |
| |
| class FakeDelegate : public ProtocolHandlerRegistry::Delegate { |
| public: |
| FakeDelegate() : force_os_failure_(false) {} |
| ~FakeDelegate() override {} |
| void RegisterExternalHandler(const std::string& protocol) override { |
| ASSERT_TRUE( |
| registered_protocols_.find(protocol) == registered_protocols_.end()); |
| registered_protocols_.insert(protocol); |
| } |
| |
| void DeregisterExternalHandler(const std::string& protocol) override { |
| registered_protocols_.erase(protocol); |
| } |
| |
| scoped_refptr<shell_integration::DefaultProtocolClientWorker> |
| CreateShellWorker( |
| const shell_integration::DefaultWebClientWorkerCallback& callback, |
| const std::string& protocol) override { |
| return new FakeProtocolClientWorker(callback, protocol, force_os_failure_); |
| } |
| |
| void RegisterWithOSAsDefaultClient( |
| const std::string& protocol, |
| ProtocolHandlerRegistry* registry) override; |
| |
| bool IsExternalHandlerRegistered(const std::string& protocol) override { |
| return registered_protocols_.find(protocol) != registered_protocols_.end(); |
| } |
| |
| bool IsFakeRegisteredWithOS(const std::string& protocol) { |
| return os_registered_protocols_.find(protocol) != |
| os_registered_protocols_.end(); |
| } |
| |
| void FakeRegisterWithOS(const std::string& protocol) { |
| os_registered_protocols_.insert(protocol); |
| } |
| |
| void Reset() { |
| registered_protocols_.clear(); |
| os_registered_protocols_.clear(); |
| force_os_failure_ = false; |
| } |
| |
| void set_force_os_failure(bool force) { force_os_failure_ = force; } |
| |
| bool force_os_failure() { return force_os_failure_; } |
| |
| private: |
| std::set<std::string> registered_protocols_; |
| std::set<std::string> os_registered_protocols_; |
| bool force_os_failure_; |
| }; |
| |
| void OnShellWorkerFinished(ProtocolHandlerRegistry* registry, |
| FakeDelegate* delegate, |
| const std::string& protocol, |
| shell_integration::DefaultWebClientState state) { |
| registry->GetDefaultWebClientCallback(protocol).Run(state); |
| if (state == shell_integration::IS_DEFAULT) { |
| delegate->FakeRegisterWithOS(protocol); |
| } |
| |
| base::MessageLoop::current()->QuitWhenIdle(); |
| } |
| |
| void FakeDelegate::RegisterWithOSAsDefaultClient( |
| const std::string& protocol, |
| ProtocolHandlerRegistry* registry) { |
| // The worker pointer is reference counted. While it is running, the |
| // message loops of the FILE and UI thread will hold references to it |
| // and it will be automatically freed once all its tasks have finished. |
| CreateShellWorker(base::Bind(OnShellWorkerFinished, registry, this, protocol), |
| protocol) |
| ->StartSetAsDefault(); |
| ASSERT_FALSE(IsFakeRegisteredWithOS(protocol)); |
| } |
| |
| class NotificationCounter : public content::NotificationObserver { |
| public: |
| explicit NotificationCounter(content::BrowserContext* context) |
| : events_(0), |
| notification_registrar_() { |
| notification_registrar_.Add(this, |
| chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED, |
| content::Source<content::BrowserContext>(context)); |
| } |
| |
| int events() { return events_; } |
| bool notified() { return events_ > 0; } |
| void Clear() { events_ = 0; } |
| void Observe(int type, |
| const content::NotificationSource& source, |
| const content::NotificationDetails& details) override { |
| ++events_; |
| } |
| |
| int events_; |
| content::NotificationRegistrar notification_registrar_; |
| }; |
| |
| class QueryProtocolHandlerOnChange |
| : public content::NotificationObserver { |
| public: |
| QueryProtocolHandlerOnChange(content::BrowserContext* context, |
| ProtocolHandlerRegistry* registry) |
| : local_registry_(registry), |
| called_(false), |
| notification_registrar_() { |
| notification_registrar_.Add(this, |
| chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED, |
| content::Source<content::BrowserContext>(context)); |
| } |
| |
| void Observe(int type, |
| const content::NotificationSource& source, |
| const content::NotificationDetails& details) override { |
| std::vector<std::string> output; |
| local_registry_->GetRegisteredProtocols(&output); |
| called_ = true; |
| } |
| |
| ProtocolHandlerRegistry* local_registry_; |
| bool called_; |
| content::NotificationRegistrar notification_registrar_; |
| }; |
| |
| // URLRequest DCHECKS that the current MessageLoop is IO. It does this because |
| // it can't check the thread id (since net can't depend on content.) We want |
| // to harness our tests so all threads use the same loop allowing us to |
| // guarantee all messages are processed.) By overriding the IsType method |
| // we basically ignore the supplied message loop type, and instead infer |
| // our type based on the current thread. GO DEPENDENCY INJECTION! |
| class TestMessageLoop : public base::MessageLoop { |
| public: |
| TestMessageLoop() {} |
| ~TestMessageLoop() override {} |
| bool IsType(base::MessageLoop::Type type) const override { |
| switch (type) { |
| case base::MessageLoop::TYPE_UI: |
| return BrowserThread::CurrentlyOn(BrowserThread::UI); |
| case base::MessageLoop::TYPE_IO: |
| return BrowserThread::CurrentlyOn(BrowserThread::IO); |
| #if defined(OS_ANDROID) |
| case base::MessageLoop::TYPE_JAVA: // fall-through |
| #endif // defined(OS_ANDROID) |
| case base::MessageLoop::TYPE_CUSTOM: |
| case base::MessageLoop::TYPE_DEFAULT: |
| return !BrowserThread::CurrentlyOn(BrowserThread::UI) && |
| !BrowserThread::CurrentlyOn(BrowserThread::IO); |
| } |
| return false; |
| } |
| }; |
| |
| } // namespace |
| |
| class ProtocolHandlerRegistryTest : public testing::Test { |
| protected: |
| ProtocolHandlerRegistryTest() |
| : ui_thread_(BrowserThread::UI, &loop_), |
| file_thread_(BrowserThread::FILE, &loop_), |
| io_thread_(BrowserThread::IO, &loop_), |
| test_protocol_handler_(CreateProtocolHandler("test", "test")) {} |
| |
| FakeDelegate* delegate() const { return delegate_; } |
| ProtocolHandlerRegistry* registry() { return registry_.get(); } |
| TestingProfile* profile() const { return profile_.get(); } |
| const ProtocolHandler& test_protocol_handler() const { |
| return test_protocol_handler_; |
| } |
| |
| ProtocolHandler CreateProtocolHandler(const std::string& protocol, |
| const GURL& url) { |
| return ProtocolHandler::CreateProtocolHandler(protocol, url); |
| } |
| |
| ProtocolHandler CreateProtocolHandler(const std::string& protocol, |
| const std::string& name) { |
| return CreateProtocolHandler(protocol, GURL("http://" + name + "/%s")); |
| } |
| |
| void RecreateRegistry(bool initialize) { |
| TeadDownRegistry(); |
| SetUpRegistry(initialize); |
| } |
| |
| int InPrefHandlerCount() { |
| const base::ListValue* in_pref_handlers = |
| profile()->GetPrefs()->GetList(prefs::kRegisteredProtocolHandlers); |
| return static_cast<int>(in_pref_handlers->GetSize()); |
| } |
| |
| int InMemoryHandlerCount() { |
| int in_memory_handler_count = 0; |
| ProtocolHandlerRegistry::ProtocolHandlerMultiMap::iterator it = |
| registry()->protocol_handlers_.begin(); |
| for (; it != registry()->protocol_handlers_.end(); ++it) |
| in_memory_handler_count += it->second.size(); |
| return in_memory_handler_count; |
| } |
| |
| int InPrefIgnoredHandlerCount() { |
| const base::ListValue* in_pref_ignored_handlers = |
| profile()->GetPrefs()->GetList(prefs::kIgnoredProtocolHandlers); |
| return static_cast<int>(in_pref_ignored_handlers->GetSize()); |
| } |
| |
| int InMemoryIgnoredHandlerCount() { |
| int in_memory_ignored_handler_count = 0; |
| ProtocolHandlerRegistry::ProtocolHandlerList::iterator it = |
| registry()->ignored_protocol_handlers_.begin(); |
| for (; it != registry()->ignored_protocol_handlers_.end(); ++it) |
| in_memory_ignored_handler_count++; |
| return in_memory_ignored_handler_count; |
| } |
| |
| // Returns a new registry, initializing it if |initialize| is true. |
| // Caller assumes ownership for the object |
| void SetUpRegistry(bool initialize) { |
| delegate_ = new FakeDelegate(); |
| registry_.reset(new ProtocolHandlerRegistry(profile(), delegate())); |
| if (initialize) registry_->InitProtocolSettings(); |
| } |
| |
| void TeadDownRegistry() { |
| registry_->Shutdown(); |
| registry_.reset(); |
| // Registry owns the delegate_ it handles deletion of that object. |
| } |
| |
| void SetUp() override { |
| profile_.reset(new TestingProfile()); |
| CHECK(profile_->GetPrefs()); |
| SetUpRegistry(true); |
| test_protocol_handler_ = |
| CreateProtocolHandler("test", GURL("http://test.com/%s")); |
| } |
| |
| void TearDown() override { TeadDownRegistry(); } |
| |
| TestMessageLoop loop_; |
| |
| private: |
| content::TestBrowserThread ui_thread_; |
| content::TestBrowserThread file_thread_; |
| content::TestBrowserThread io_thread_; |
| |
| std::unique_ptr<TestingProfile> profile_; |
| FakeDelegate* delegate_; // Registry assumes ownership of delegate_. |
| std::unique_ptr<ProtocolHandlerRegistry> registry_; |
| ProtocolHandler test_protocol_handler_; |
| }; |
| |
| TEST_F(ProtocolHandlerRegistryTest, AcceptProtocolHandlerHandlesProtocol) { |
| ASSERT_FALSE(registry()->IsHandledProtocol("test")); |
| registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); |
| ASSERT_TRUE(registry()->IsHandledProtocol("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, DeniedProtocolIsntHandledUntilAccepted) { |
| registry()->OnDenyRegisterProtocolHandler(test_protocol_handler()); |
| ASSERT_FALSE(registry()->IsHandledProtocol("test")); |
| registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); |
| ASSERT_TRUE(registry()->IsHandledProtocol("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, ClearDefaultMakesProtocolNotHandled) { |
| registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); |
| registry()->ClearDefault("test"); |
| ASSERT_FALSE(registry()->IsHandledProtocol("test")); |
| ASSERT_TRUE(registry()->GetHandlerFor("test").IsEmpty()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, DisableDeregistersProtocolHandlers) { |
| ASSERT_FALSE(delegate()->IsExternalHandlerRegistered("test")); |
| registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); |
| ASSERT_TRUE(delegate()->IsExternalHandlerRegistered("test")); |
| |
| registry()->Disable(); |
| ASSERT_FALSE(delegate()->IsExternalHandlerRegistered("test")); |
| registry()->Enable(); |
| ASSERT_TRUE(delegate()->IsExternalHandlerRegistered("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, IgnoreProtocolHandler) { |
| registry()->OnIgnoreRegisterProtocolHandler(test_protocol_handler()); |
| ASSERT_TRUE(registry()->IsIgnored(test_protocol_handler())); |
| |
| registry()->RemoveIgnoredHandler(test_protocol_handler()); |
| ASSERT_FALSE(registry()->IsIgnored(test_protocol_handler())); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, IgnoreEquivalentProtocolHandler) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s")); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s")); |
| |
| registry()->OnIgnoreRegisterProtocolHandler(ph1); |
| ASSERT_TRUE(registry()->IsIgnored(ph1)); |
| ASSERT_TRUE(registry()->HasIgnoredEquivalent(ph2)); |
| |
| registry()->RemoveIgnoredHandler(ph1); |
| ASSERT_FALSE(registry()->IsIgnored(ph1)); |
| ASSERT_FALSE(registry()->HasIgnoredEquivalent(ph2)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, SaveAndLoad) { |
| ProtocolHandler stuff_protocol_handler( |
| CreateProtocolHandler("stuff", "stuff")); |
| registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); |
| registry()->OnIgnoreRegisterProtocolHandler(stuff_protocol_handler); |
| |
| ASSERT_TRUE(registry()->IsHandledProtocol("test")); |
| ASSERT_TRUE(registry()->IsIgnored(stuff_protocol_handler)); |
| delegate()->Reset(); |
| RecreateRegistry(true); |
| ASSERT_TRUE(registry()->IsHandledProtocol("test")); |
| ASSERT_TRUE(registry()->IsIgnored(stuff_protocol_handler)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestEnabledDisabled) { |
| registry()->Disable(); |
| ASSERT_FALSE(registry()->enabled()); |
| registry()->Enable(); |
| ASSERT_TRUE(registry()->enabled()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, |
| DisallowRegisteringExternallyHandledProtocols) { |
| delegate()->RegisterExternalHandler("test"); |
| ASSERT_FALSE(registry()->CanSchemeBeOverridden("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, RemovingHandlerMeansItCanBeAddedAgain) { |
| registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); |
| ASSERT_TRUE(registry()->CanSchemeBeOverridden("test")); |
| registry()->RemoveHandler(test_protocol_handler()); |
| ASSERT_TRUE(registry()->CanSchemeBeOverridden("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestStartsAsDefault) { |
| registry()->OnAcceptRegisterProtocolHandler(test_protocol_handler()); |
| ASSERT_TRUE(registry()->IsDefault(test_protocol_handler())); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestClearDefault) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->ClearDefault("test"); |
| ASSERT_FALSE(registry()->IsDefault(ph1)); |
| ASSERT_FALSE(registry()->IsDefault(ph2)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestGetHandlerFor) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| ASSERT_EQ(ph2, registry()->GetHandlerFor("test")); |
| ASSERT_TRUE(registry()->IsHandledProtocol("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestMostRecentHandlerIsDefault) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| ASSERT_FALSE(registry()->IsDefault(ph1)); |
| ASSERT_TRUE(registry()->IsDefault(ph2)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestOnAcceptRegisterProtocolHandler) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| ASSERT_TRUE(registry()->IsDefault(ph1)); |
| ASSERT_FALSE(registry()->IsDefault(ph2)); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| ASSERT_FALSE(registry()->IsDefault(ph1)); |
| ASSERT_TRUE(registry()->IsDefault(ph2)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestDefaultSaveLoad) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| registry()->OnDenyRegisterProtocolHandler(ph1); |
| registry()->OnDenyRegisterProtocolHandler(ph2); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| registry()->Disable(); |
| |
| RecreateRegistry(true); |
| |
| ASSERT_FALSE(registry()->enabled()); |
| registry()->Enable(); |
| ASSERT_FALSE(registry()->IsDefault(ph1)); |
| ASSERT_TRUE(registry()->IsDefault(ph2)); |
| |
| RecreateRegistry(true); |
| ASSERT_TRUE(registry()->enabled()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestRemoveHandler) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| |
| registry()->RemoveHandler(ph1); |
| ASSERT_FALSE(registry()->IsRegistered(ph1)); |
| ASSERT_FALSE(registry()->IsHandledProtocol("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestIsRegistered) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| |
| ASSERT_TRUE(registry()->IsRegistered(ph1)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestIsEquivalentRegistered) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s")); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s")); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| |
| ASSERT_TRUE(registry()->IsRegistered(ph1)); |
| ASSERT_TRUE(registry()->HasRegisteredEquivalent(ph2)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestSilentlyRegisterHandler) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/1/%s")); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/2/%s")); |
| ProtocolHandler ph3 = CreateProtocolHandler("ignore", GURL("http://test/%s")); |
| ProtocolHandler ph4 = CreateProtocolHandler("ignore", GURL("http://test/%s")); |
| |
| ASSERT_FALSE(registry()->SilentlyHandleRegisterHandlerRequest(ph1)); |
| ASSERT_FALSE(registry()->IsRegistered(ph1)); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| ASSERT_TRUE(registry()->IsRegistered(ph1)); |
| |
| ASSERT_TRUE(registry()->SilentlyHandleRegisterHandlerRequest(ph2)); |
| ASSERT_FALSE(registry()->IsRegistered(ph1)); |
| ASSERT_TRUE(registry()->IsRegistered(ph2)); |
| |
| ASSERT_FALSE(registry()->SilentlyHandleRegisterHandlerRequest(ph3)); |
| ASSERT_FALSE(registry()->IsRegistered(ph3)); |
| |
| registry()->OnIgnoreRegisterProtocolHandler(ph3); |
| ASSERT_FALSE(registry()->IsRegistered(ph3)); |
| ASSERT_TRUE(registry()->IsIgnored(ph3)); |
| |
| ASSERT_TRUE(registry()->SilentlyHandleRegisterHandlerRequest(ph4)); |
| ASSERT_FALSE(registry()->IsRegistered(ph4)); |
| ASSERT_TRUE(registry()->HasIgnoredEquivalent(ph4)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestRemoveHandlerRemovesDefault) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| ProtocolHandler ph3 = CreateProtocolHandler("test", "test3"); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| registry()->OnAcceptRegisterProtocolHandler(ph3); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->RemoveHandler(ph1); |
| ASSERT_FALSE(registry()->IsDefault(ph1)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestGetHandlersFor) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("test", "test2"); |
| ProtocolHandler ph3 = CreateProtocolHandler("test", "test3"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| registry()->OnAcceptRegisterProtocolHandler(ph3); |
| |
| ProtocolHandlerRegistry::ProtocolHandlerList handlers = |
| registry()->GetHandlersFor("test"); |
| ASSERT_EQ(static_cast<size_t>(3), handlers.size()); |
| |
| ASSERT_EQ(ph3, handlers[0]); |
| ASSERT_EQ(ph2, handlers[1]); |
| ASSERT_EQ(ph1, handlers[2]); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestGetRegisteredProtocols) { |
| std::vector<std::string> protocols; |
| registry()->GetRegisteredProtocols(&protocols); |
| ASSERT_EQ(static_cast<size_t>(0), protocols.size()); |
| |
| registry()->GetHandlersFor("test"); |
| |
| protocols.clear(); |
| registry()->GetRegisteredProtocols(&protocols); |
| ASSERT_EQ(static_cast<size_t>(0), protocols.size()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestIsHandledProtocol) { |
| registry()->GetHandlersFor("test"); |
| ASSERT_FALSE(registry()->IsHandledProtocol("test")); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestNotifications) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| NotificationCounter counter(profile()); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| ASSERT_TRUE(counter.notified()); |
| counter.Clear(); |
| |
| registry()->Disable(); |
| ASSERT_TRUE(counter.notified()); |
| counter.Clear(); |
| |
| registry()->Enable(); |
| ASSERT_TRUE(counter.notified()); |
| counter.Clear(); |
| |
| registry()->RemoveHandler(ph1); |
| ASSERT_TRUE(counter.notified()); |
| counter.Clear(); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestReentrantNotifications) { |
| QueryProtocolHandlerOnChange queryer(profile(), registry()); |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| ASSERT_TRUE(queryer.called_); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestProtocolsWithNoDefaultAreHandled) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->ClearDefault("test"); |
| std::vector<std::string> handled_protocols; |
| registry()->GetRegisteredProtocols(&handled_protocols); |
| ASSERT_EQ(static_cast<size_t>(1), handled_protocols.size()); |
| ASSERT_EQ("test", handled_protocols[0]); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestDisablePreventsHandling) { |
| ProtocolHandler ph1 = CreateProtocolHandler("test", "test1"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| ASSERT_TRUE(registry()->IsHandledProtocol("test")); |
| registry()->Disable(); |
| ASSERT_FALSE(registry()->IsHandledProtocol("test")); |
| } |
| |
| // TODO(smckay): This is much more appropriately an integration |
| // test. Make that so, then update the |
| // ShellIntegretion{Delegate,Callback,Worker} test classes we use to fully |
| // isolate this test from the FILE thread. |
| TEST_F(ProtocolHandlerRegistryTest, TestOSRegistration) { |
| ProtocolHandler ph_do1 = CreateProtocolHandler("do", "test1"); |
| ProtocolHandler ph_do2 = CreateProtocolHandler("do", "test2"); |
| ProtocolHandler ph_dont = CreateProtocolHandler("dont", "test"); |
| |
| ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("do")); |
| ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("dont")); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph_do1); |
| registry()->OnDenyRegisterProtocolHandler(ph_dont); |
| base::RunLoop().Run(); // FILE thread needs to run. |
| ASSERT_TRUE(delegate()->IsFakeRegisteredWithOS("do")); |
| ASSERT_FALSE(delegate()->IsFakeRegisteredWithOS("dont")); |
| |
| // This should not register with the OS, if it does the delegate |
| // will assert for us. We don't need to wait for the message loop |
| // as it should not go through to the shell worker. |
| registry()->OnAcceptRegisterProtocolHandler(ph_do2); |
| } |
| |
| #if defined(OS_LINUX) |
| // TODO(benwells): When Linux support is more reliable and |
| // http://crbug.com/88255 is fixed this test will pass. |
| #define MAYBE_TestOSRegistrationFailure DISABLED_TestOSRegistrationFailure |
| #else |
| #define MAYBE_TestOSRegistrationFailure TestOSRegistrationFailure |
| #endif |
| |
| // TODO(smckay): This is much more appropriately an integration |
| // test. Make that so, then update the |
| // ShellIntegretion{Delegate,Callback,Worker} test classes we use to fully |
| // isolate this test from the FILE thread. |
| TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestOSRegistrationFailure) { |
| ProtocolHandler ph_do = CreateProtocolHandler("do", "test1"); |
| ProtocolHandler ph_dont = CreateProtocolHandler("dont", "test"); |
| |
| ASSERT_FALSE(registry()->IsHandledProtocol("do")); |
| ASSERT_FALSE(registry()->IsHandledProtocol("dont")); |
| |
| registry()->OnAcceptRegisterProtocolHandler(ph_do); |
| base::RunLoop().Run(); // FILE thread needs to run. |
| delegate()->set_force_os_failure(true); |
| registry()->OnAcceptRegisterProtocolHandler(ph_dont); |
| base::RunLoop().Run(); // FILE thread needs to run. |
| ASSERT_TRUE(registry()->IsHandledProtocol("do")); |
| ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("do").size()); |
| ASSERT_FALSE(registry()->IsHandledProtocol("dont")); |
| ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("dont").size()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestMaybeCreateTaskWorksFromIOThread) { |
| ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| GURL url("mailto:someone@something.com"); |
| |
| std::unique_ptr<net::URLRequestJobFactory> interceptor( |
| registry()->CreateJobInterceptorFactory()); |
| AssertIntercepted(url, interceptor.get()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, |
| TestIsHandledProtocolWorksOnIOThread) { |
| std::string scheme("mailto"); |
| ProtocolHandler ph1 = CreateProtocolHandler(scheme, "test1"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| |
| std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor( |
| registry()->CreateJobInterceptorFactory()); |
| AssertWillHandle(scheme, true, interceptor.get()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestRemovingDefaultFallsBackToOldDefault) { |
| ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("mailto", "test2"); |
| ProtocolHandler ph3 = CreateProtocolHandler("mailto", "test3"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| registry()->OnAcceptRegisterProtocolHandler(ph3); |
| |
| ASSERT_TRUE(registry()->IsDefault(ph3)); |
| registry()->RemoveHandler(ph3); |
| ASSERT_TRUE(registry()->IsDefault(ph2)); |
| registry()->OnAcceptRegisterProtocolHandler(ph3); |
| ASSERT_TRUE(registry()->IsDefault(ph3)); |
| registry()->RemoveHandler(ph2); |
| ASSERT_TRUE(registry()->IsDefault(ph3)); |
| registry()->RemoveHandler(ph3); |
| ASSERT_TRUE(registry()->IsDefault(ph1)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestRemovingDefaultDoesntChangeHandlers) { |
| ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1"); |
| ProtocolHandler ph2 = CreateProtocolHandler("mailto", "test2"); |
| ProtocolHandler ph3 = CreateProtocolHandler("mailto", "test3"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| registry()->OnAcceptRegisterProtocolHandler(ph3); |
| registry()->RemoveHandler(ph3); |
| |
| ProtocolHandlerRegistry::ProtocolHandlerList handlers = |
| registry()->GetHandlersFor("mailto"); |
| ASSERT_EQ(static_cast<size_t>(2), handlers.size()); |
| |
| ASSERT_EQ(ph2, handlers[0]); |
| ASSERT_EQ(ph1, handlers[1]); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestClearDefaultGetsPropagatedToIO) { |
| std::string scheme("mailto"); |
| ProtocolHandler ph1 = CreateProtocolHandler(scheme, "test1"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->ClearDefault(scheme); |
| |
| std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor( |
| registry()->CreateJobInterceptorFactory()); |
| AssertWillHandle(scheme, false, interceptor.get()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestLoadEnabledGetsPropogatedToIO) { |
| std::string mailto("mailto"); |
| ProtocolHandler ph1 = CreateProtocolHandler(mailto, "MailtoHandler"); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| |
| std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor( |
| registry()->CreateJobInterceptorFactory()); |
| AssertWillHandle(mailto, true, interceptor.get()); |
| registry()->Disable(); |
| AssertWillHandle(mailto, false, interceptor.get()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestReplaceHandler) { |
| ProtocolHandler ph1 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/%s")); |
| ProtocolHandler ph2 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| ASSERT_TRUE(registry()->AttemptReplace(ph2)); |
| const ProtocolHandler& handler(registry()->GetHandlerFor("mailto")); |
| ASSERT_EQ(handler.url(), ph2.url()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestReplaceNonDefaultHandler) { |
| ProtocolHandler ph1 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/%s")); |
| ProtocolHandler ph2 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); |
| ProtocolHandler ph3 = |
| CreateProtocolHandler("mailto", GURL("http://else.com/%s")); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph3); |
| ASSERT_TRUE(registry()->AttemptReplace(ph2)); |
| const ProtocolHandler& handler(registry()->GetHandlerFor("mailto")); |
| ASSERT_EQ(handler.url(), ph3.url()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestReplaceRemovesStaleHandlers) { |
| ProtocolHandler ph1 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/%s")); |
| ProtocolHandler ph2 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); |
| ProtocolHandler ph3 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/third/%s")); |
| registry()->OnAcceptRegisterProtocolHandler(ph1); |
| registry()->OnAcceptRegisterProtocolHandler(ph2); |
| |
| // This should replace the previous two handlers. |
| ASSERT_TRUE(registry()->AttemptReplace(ph3)); |
| const ProtocolHandler& handler(registry()->GetHandlerFor("mailto")); |
| ASSERT_EQ(handler.url(), ph3.url()); |
| registry()->RemoveHandler(ph3); |
| ASSERT_TRUE(registry()->GetHandlerFor("mailto").IsEmpty()); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestIsSameOrigin) { |
| ProtocolHandler ph1 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/%s")); |
| ProtocolHandler ph2 = |
| CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s")); |
| ProtocolHandler ph3 = |
| CreateProtocolHandler("mailto", GURL("http://other.com/%s")); |
| ASSERT_EQ(ph1.url().GetOrigin() == ph2.url().GetOrigin(), |
| ph1.IsSameOrigin(ph2)); |
| ASSERT_EQ(ph1.url().GetOrigin() == ph2.url().GetOrigin(), |
| ph2.IsSameOrigin(ph1)); |
| ASSERT_EQ(ph2.url().GetOrigin() == ph3.url().GetOrigin(), |
| ph2.IsSameOrigin(ph3)); |
| ASSERT_EQ(ph3.url().GetOrigin() == ph2.url().GetOrigin(), |
| ph3.IsSameOrigin(ph2)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestInstallDefaultHandler) { |
| RecreateRegistry(false); |
| registry()->AddPredefinedHandler( |
| CreateProtocolHandler("test", GURL("http://test.com/%s"))); |
| registry()->InitProtocolSettings(); |
| std::vector<std::string> protocols; |
| registry()->GetRegisteredProtocols(&protocols); |
| ASSERT_EQ(static_cast<size_t>(1), protocols.size()); |
| } |
| |
| #define URL_p1u1 "http://p1u1.com/%s" |
| #define URL_p1u2 "http://p1u2.com/%s" |
| #define URL_p1u3 "http://p1u3.com/%s" |
| #define URL_p2u1 "http://p2u1.com/%s" |
| #define URL_p2u2 "http://p2u2.com/%s" |
| #define URL_p3u1 "http://p3u1.com/%s" |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestPrefPolicyOverlapRegister) { |
| base::ListValue handlers_registered_by_pref; |
| base::ListValue handlers_registered_by_policy; |
| |
| handlers_registered_by_pref.Append( |
| GetProtocolHandlerValueWithDefault("p1", URL_p1u2, true)); |
| handlers_registered_by_pref.Append( |
| GetProtocolHandlerValueWithDefault("p1", URL_p1u1, true)); |
| handlers_registered_by_pref.Append( |
| GetProtocolHandlerValueWithDefault("p1", URL_p1u2, false)); |
| |
| handlers_registered_by_policy.Append( |
| GetProtocolHandlerValueWithDefault("p1", URL_p1u1, false)); |
| handlers_registered_by_policy.Append( |
| GetProtocolHandlerValueWithDefault("p3", URL_p3u1, true)); |
| |
| profile()->GetPrefs()->Set(prefs::kRegisteredProtocolHandlers, |
| handlers_registered_by_pref); |
| profile()->GetPrefs()->Set(prefs::kPolicyRegisteredProtocolHandlers, |
| handlers_registered_by_policy); |
| registry()->InitProtocolSettings(); |
| |
| // Duplicate p1u2 eliminated in memory but not yet saved in pref |
| ProtocolHandler p1u1 = CreateProtocolHandler("p1", GURL(URL_p1u1)); |
| ProtocolHandler p1u2 = CreateProtocolHandler("p1", GURL(URL_p1u2)); |
| ASSERT_EQ(InPrefHandlerCount(), 3); |
| ASSERT_EQ(InMemoryHandlerCount(), 3); |
| ASSERT_TRUE(registry()->IsDefault(p1u1)); |
| ASSERT_FALSE(registry()->IsDefault(p1u2)); |
| |
| ProtocolHandler p2u1 = CreateProtocolHandler("p2", GURL(URL_p2u1)); |
| registry()->OnDenyRegisterProtocolHandler(p2u1); |
| |
| // Duplicate p1u2 saved in pref and a new handler added to pref and memory |
| ASSERT_EQ(InPrefHandlerCount(), 3); |
| ASSERT_EQ(InMemoryHandlerCount(), 4); |
| ASSERT_FALSE(registry()->IsDefault(p2u1)); |
| |
| registry()->RemoveHandler(p1u1); |
| |
| // p1u1 removed from user pref but not from memory due to policy. |
| ASSERT_EQ(InPrefHandlerCount(), 2); |
| ASSERT_EQ(InMemoryHandlerCount(), 4); |
| ASSERT_TRUE(registry()->IsDefault(p1u1)); |
| |
| ProtocolHandler p3u1 = CreateProtocolHandler("p3", GURL(URL_p3u1)); |
| registry()->RemoveHandler(p3u1); |
| |
| // p3u1 not removed from memory due to policy and it was never in pref. |
| ASSERT_EQ(InPrefHandlerCount(), 2); |
| ASSERT_EQ(InMemoryHandlerCount(), 4); |
| ASSERT_TRUE(registry()->IsDefault(p3u1)); |
| |
| registry()->RemoveHandler(p1u2); |
| |
| // p1u2 removed from user pref and memory. |
| ASSERT_EQ(InPrefHandlerCount(), 1); |
| ASSERT_EQ(InMemoryHandlerCount(), 3); |
| ASSERT_TRUE(registry()->IsDefault(p1u1)); |
| |
| ProtocolHandler p1u3 = CreateProtocolHandler("p1", GURL(URL_p1u3)); |
| registry()->OnAcceptRegisterProtocolHandler(p1u3); |
| |
| // p1u3 added to pref and memory. |
| ASSERT_EQ(InPrefHandlerCount(), 2); |
| ASSERT_EQ(InMemoryHandlerCount(), 4); |
| ASSERT_FALSE(registry()->IsDefault(p1u1)); |
| ASSERT_TRUE(registry()->IsDefault(p1u3)); |
| |
| registry()->RemoveHandler(p1u3); |
| |
| // p1u3 the default handler for p1 removed from user pref and memory. |
| ASSERT_EQ(InPrefHandlerCount(), 1); |
| ASSERT_EQ(InMemoryHandlerCount(), 3); |
| ASSERT_FALSE(registry()->IsDefault(p1u3)); |
| ASSERT_TRUE(registry()->IsDefault(p1u1)); |
| ASSERT_TRUE(registry()->IsDefault(p3u1)); |
| ASSERT_FALSE(registry()->IsDefault(p2u1)); |
| } |
| |
| TEST_F(ProtocolHandlerRegistryTest, TestPrefPolicyOverlapIgnore) { |
| base::ListValue handlers_ignored_by_pref; |
| base::ListValue handlers_ignored_by_policy; |
| |
| handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p1", URL_p1u1)); |
| handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p1", URL_p1u2)); |
| handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p1", URL_p1u2)); |
| handlers_ignored_by_pref.Append(GetProtocolHandlerValue("p3", URL_p3u1)); |
| |
| handlers_ignored_by_policy.Append(GetProtocolHandlerValue("p1", URL_p1u2)); |
| handlers_ignored_by_policy.Append(GetProtocolHandlerValue("p1", URL_p1u3)); |
| handlers_ignored_by_policy.Append(GetProtocolHandlerValue("p2", URL_p2u1)); |
| |
| profile()->GetPrefs()->Set(prefs::kIgnoredProtocolHandlers, |
| handlers_ignored_by_pref); |
| profile()->GetPrefs()->Set(prefs::kPolicyIgnoredProtocolHandlers, |
| handlers_ignored_by_policy); |
| registry()->InitProtocolSettings(); |
| |
| // Duplicate p1u2 eliminated in memory but not yet saved in pref |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 4); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 5); |
| |
| ProtocolHandler p2u2 = CreateProtocolHandler("p2", GURL(URL_p2u2)); |
| registry()->OnIgnoreRegisterProtocolHandler(p2u2); |
| |
| // Duplicate p1u2 eliminated in pref, p2u2 added to pref and memory. |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 4); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 6); |
| |
| ProtocolHandler p2u1 = CreateProtocolHandler("p2", GURL(URL_p2u1)); |
| registry()->RemoveIgnoredHandler(p2u1); |
| |
| // p2u1 installed by policy so cant be removed. |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 4); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 6); |
| |
| ProtocolHandler p1u2 = CreateProtocolHandler("p1", GURL(URL_p1u2)); |
| registry()->RemoveIgnoredHandler(p1u2); |
| |
| // p1u2 installed by policy and pref so it is removed from pref and not from |
| // memory. |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 3); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 6); |
| |
| ProtocolHandler p1u1 = CreateProtocolHandler("p1", GURL(URL_p1u1)); |
| registry()->RemoveIgnoredHandler(p1u1); |
| |
| // p1u1 installed by pref so it is removed from pref and memory. |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 2); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 5); |
| |
| registry()->RemoveIgnoredHandler(p2u2); |
| |
| // p2u2 installed by user so it is removed from pref and memory. |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 1); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4); |
| |
| registry()->OnIgnoreRegisterProtocolHandler(p2u1); |
| |
| // p2u1 installed by user but it is already installed by policy, so it is |
| // added to pref. |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 2); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4); |
| |
| registry()->RemoveIgnoredHandler(p2u1); |
| |
| // p2u1 installed by user and policy, so it is removed from pref alone. |
| ASSERT_EQ(InPrefIgnoredHandlerCount(), 1); |
| ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4); |
| } |