Convert ProtocolHandlerRegistry to be a ProfileKeyedService.

chrome/browser/custom_handlers/protocol_handler_registry_unittest.cc

 // 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 <set>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 184 matching lines @@
 }  // namespace
 
 class ProtocolHandlerRegistryTest : public testing::Test {
  protected:
   ProtocolHandlerRegistryTest()
       : test_protocol_handler_(CreateProtocolHandler("test", "test")) {}
 
   FakeDelegate* delegate() const { return delegate_; }
   TestingProfile* profile() const { return profile_.get(); }
   PrefService* pref_service() const { return profile_->GetPrefs(); }
-  ProtocolHandlerRegistry* registry() const { return registry_.get(); }
+  ProtocolHandlerRegistry* registry() const { return registry_; }
   const ProtocolHandler& test_protocol_handler() const {
     return test_protocol_handler_;
   }
 
   ProtocolHandler CreateProtocolHandler(const std::string& protocol,
                                         const GURL& url,
                                         const std::string& title) {
     return ProtocolHandler::CreateProtocolHandler(protocol, url,
         UTF8ToUTF16(title));
   }
@@ skipping 37 matching lines @@
     delegate_ = new FakeDelegate();
     registry_ = new ProtocolHandlerRegistry(profile(), delegate());
     registry_->Load();
     test_protocol_handler_ =
         CreateProtocolHandler("test", GURL("http://test.com/%s"), "Test");
 
     ProtocolHandlerRegistry::RegisterPrefs(pref_service());
   }
 
   virtual void TearDown() {
     registry_->Finalize();

[Elliot Glaysher, 2012/06/11 19:43:16]

(And change the name here)

[Steve McKay, 2012/06/11 22:09:38]

Done.

     registry_ = NULL;
     io_thread_->Stop();
     io_thread_.reset(NULL);
     file_thread_->Stop();
     file_thread_.reset(NULL);
     ui_thread_.reset(NULL);
     ui_message_loop_.reset(NULL);
   }
 
   bool enabled_io() {
     return registry()->enabled_io_;
   }
 
   scoped_ptr<MessageLoopForUI> ui_message_loop_;
   scoped_ptr<content::TestBrowserThread> ui_thread_;
   scoped_ptr<content::TestBrowserThread> io_thread_;
   scoped_ptr<content::TestBrowserThread> file_thread_;
 
   FakeDelegate* delegate_;
   scoped_ptr<TestingProfile> profile_;
-  scoped_refptr<ProtocolHandlerRegistry> registry_;
+  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) {
@@ skipping 357 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           MessageLoop::QuitClosure());
   scoped_refptr<net::URLRequestJob> job(registry->MaybeCreateJob(&request));
   ASSERT_TRUE(job.get() != NULL);
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestMaybeCreateTaskWorksFromIOThread) {
   ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   GURL url("mailto:someone@something.com");
-  scoped_refptr<ProtocolHandlerRegistry> r(registry());
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(MakeRequest, url, r));
+                          base::Bind(MakeRequest,
+                                     url,
+                                     base::Unretained(registry_)));
   MessageLoop::current()->Run();
 }
 
 static void CheckIsHandled(const std::string& scheme, bool expected,
     ProtocolHandlerRegistry* registry) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           MessageLoop::QuitClosure());
   ASSERT_EQ(expected, registry->IsHandledProtocolIO(scheme));
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestIsHandledProtocolWorksOnIOThread) {
   std::string scheme("mailto");
   ProtocolHandler ph1 = CreateProtocolHandler(scheme, "test1");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
-  scoped_refptr<ProtocolHandlerRegistry> r(registry());
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(CheckIsHandled, scheme, true, r));
+      base::Bind(CheckIsHandled, scheme, true, base::Unretained(registry_)));
 }
 
 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);
 
@@ skipping 23 matching lines @@
 
   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);
-  scoped_refptr<ProtocolHandlerRegistry> r(registry());
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(CheckIsHandled, scheme, false, r));
+      base::Bind(CheckIsHandled, scheme, false, base::Unretained(registry_)));
 }
 
 static void QuitUILoop() {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           MessageLoop::QuitClosure());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestLoadEnabledGetsPropogatedToIO) {
   registry()->Disable();
   ReloadProtocolHandlerRegistry();
@@ skipping 62 matching lines @@
   ASSERT_EQ(ph3.url().GetOrigin() == ph2.url().GetOrigin(),
       ph3.IsSameOrigin(ph2));
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestInstallDefaultHandler) {
   ReloadProtocolHandlerRegistryAndInstallDefaultHandler();
   std::vector<std::string> protocols;
   registry()->GetRegisteredProtocols(&protocols);
   ASSERT_EQ(static_cast<size_t>(1), protocols.size());
 }