[Cleanup] Used scoped pointers in KeyedServiceFactory's SetTestingFactory functions.

chrome/browser/extensions/api/mdns/mdns_api_unittest.cc

 // Copyright 2015 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 "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/mdns/mdns_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/common/extensions/api/mdns.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "extensions/browser/event_router_factory.h"
-#include "extensions/browser/extension_prefs_factory.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 namespace {
 
-KeyedService* MDnsAPITestingFactoryFunction(content::BrowserContext* context) {
-  return new MDnsAPI(context);
+scoped_ptr<KeyedService> MDnsAPITestingFactoryFunction(
+    content::BrowserContext* context) {
+  return make_scoped_ptr(new MDnsAPI(context));
 }
 
-KeyedService* BuildEventRouter(content::BrowserContext* profile) {
-  return new extensions::EventRouter(
-      profile,
-      ExtensionPrefsFactory::GetInstance()->GetForBrowserContext((profile)));
+scoped_ptr<KeyedService> BuildEventRouter(content::BrowserContext* context) {
+  return make_scoped_ptr(
+      new extensions::EventRouter(context, ExtensionPrefs::Get(context)));
 }
 
 // For ExtensionService interface when it requires a path that is not used.
 base::FilePath bogus_file_pathname(const std::string& name) {
   return base::FilePath(FILE_PATH_LITERAL("//foobar_nonexistent"))
       .AppendASCII(name);
 }
 
 class MockDnsSdRegistry : public DnsSdRegistry {
  public:
@@ skipping 45 matching lines @@
     render_process_host_.reset(
         new content::MockRenderProcessHost(browser_context()));
   }
 
   void TearDown() override {
     EXPECT_CALL(*dns_sd_registry(),
                 RemoveObserver(MDnsAPI::Get(browser_context())))
         .Times(1);
     render_process_host_.reset();
     extensions::ExtensionServiceTestBase::TearDown();
-    MDnsAPI::GetFactoryInstance()->SetTestingFactory(
-        browser_context(),
-        nullptr);
-
-    registry_ = nullptr;
   }
 
   virtual MockDnsSdRegistry* dns_sd_registry() {
     return registry_;
   }
 
   // Constructs an extension according to the parameters that matter most to
   // MDnsAPI the local unit tests.
   const scoped_refptr<extensions::Extension> CreateExtension(
       std::string name,
@@ skipping 108 matching lines @@
                            ExtensionPrefs* extension_prefs) :
       EventRouter(browser_context, extension_prefs) {}
   virtual ~MockEventRouter() {}
 
   virtual void BroadcastEvent(scoped_ptr<Event> event) {
     BroadcastEventPtr(event.get());
   }
   MOCK_METHOD1(BroadcastEventPtr, void(Event* event));
 };
 
-KeyedService* MockEventRouterFactoryFunction(content::BrowserContext* profile) {
-  return new MockEventRouter(
-      profile,
-      ExtensionPrefsFactory::GetInstance()->GetForBrowserContext((profile)));
+scoped_ptr<KeyedService> MockEventRouterFactoryFunction(
+    content::BrowserContext* context) {
+  return make_scoped_ptr(
+      new MockEventRouter(context, ExtensionPrefs::Get(context)));
 }
 
 class MDnsAPIMaxServicesTest : public MDnsAPITest {
  public:
   MockEventRouter* event_router() {
     return static_cast<MockEventRouter*>(EventRouter::Get(browser_context()));
   }
 };
 
 class EventServiceListSizeMatcher :
@@ skipping 65 matching lines @@
       *event_router(),
       BroadcastEventPtr(
           testing::Pointee(EventServiceListSize(size_t(64)))))
       .Times(1);
   dns_sd_registry()->DispatchMDnsEvent("_testing._tcp.local", services);
 }
 
 } // empty namespace
 
 } // namespace extensions