Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

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 "chrome/browser/extensions/api/mdns/mdns_api.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.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_listener_map.h"
 #include "extensions/browser/event_router_factory.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
@@ skipping 10 matching lines @@
 
 const char kExtId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
 const char kService1[] = "service1";
 const char kService2[] = "service2";
 
 // Registers a new EventListener for |service_types| in |listener_list|.
 void AddEventListener(
     const std::string& extension_id,
     const std::string& service_type,
     extensions::EventListenerMap::ListenerList* listener_list) {
-  scoped_ptr<base::DictionaryValue> filter(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> filter(new base::DictionaryValue);
   filter->SetString(kEventFilterServiceTypeKey, service_type);
   listener_list->push_back(make_linked_ptr(
       EventListener::ForExtension(kEventFilterServiceTypeKey, extension_id,
                                   nullptr, std::move(filter))
           .release()));
 }
 
 class NullDelegate : public EventListenerMap::Delegate {
  public:
   void OnListenerAdded(const EventListener* listener) override {}
   void OnListenerRemoved(const EventListener* listener) override {}
 };
 
 // Testing subclass of MDnsAPI which replaces calls to core browser components
 // that we don't want to have to instantiate or mock for these tests.
 class MockedMDnsAPI : public MDnsAPI {
  public:
   explicit MockedMDnsAPI(content::BrowserContext* context) : MDnsAPI(context) {}
 
  public:
   MOCK_CONST_METHOD2(IsMDnsAllowed,
                      bool(const std::string& extension_id,
                           const std::string& service_type));
 
   MOCK_METHOD0(GetEventListeners,
                const extensions::EventListenerMap::ListenerList&());
 };
 
-scoped_ptr<KeyedService> MockedMDnsAPITestingFactoryFunction(
+std::unique_ptr<KeyedService> MockedMDnsAPITestingFactoryFunction(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new MockedMDnsAPI(context));
+  return base::WrapUnique(new MockedMDnsAPI(context));
 }
 
-scoped_ptr<KeyedService> MDnsAPITestingFactoryFunction(
+std::unique_ptr<KeyedService> MDnsAPITestingFactoryFunction(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new MDnsAPI(context));
+  return base::WrapUnique(new MDnsAPI(context));
 }
 
-scoped_ptr<KeyedService> BuildEventRouter(content::BrowserContext* context) {
-  return make_scoped_ptr(
+std::unique_ptr<KeyedService> BuildEventRouter(
+    content::BrowserContext* context) {
+  return base::WrapUnique(
       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 {
@@ skipping 17 matching lines @@
   extensions::DnsSdRegistry::DnsSdObserver* api_;
 };
 
 class MockEventRouter : public EventRouter {
  public:
   explicit MockEventRouter(content::BrowserContext* browser_context,
                            ExtensionPrefs* extension_prefs)
       : EventRouter(browser_context, extension_prefs) {}
   virtual ~MockEventRouter() {}
 
-  virtual void BroadcastEvent(scoped_ptr<Event> event) {
+  virtual void BroadcastEvent(std::unique_ptr<Event> event) {
     BroadcastEventPtr(event.get());
   }
   MOCK_METHOD1(BroadcastEventPtr, void(Event* event));
 };
 
-scoped_ptr<KeyedService> MockEventRouterFactoryFunction(
+std::unique_ptr<KeyedService> MockEventRouterFactoryFunction(
     content::BrowserContext* context) {
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new MockEventRouter(context, ExtensionPrefs::Get(context)));
 }
 
 class EventServiceListSizeMatcher
     : public testing::MatcherInterface<const Event&> {
  public:
   explicit EventServiceListSizeMatcher(size_t expected_size)
       : expected_size_(expected_size) {}
 
   virtual bool MatchAndExplain(const Event& e,
@@ skipping 60 matching lines @@
                                                          &BuildEventRouter);
 
     // Do some sanity checking
     ASSERT_TRUE(MDnsAPI::Get(browser_context()));      // constructs MDnsAPI
     ASSERT_TRUE(EventRouter::Get(browser_context()));  // constructs EventRouter
 
     registry_ = new MockDnsSdRegistry(MDnsAPI::Get(browser_context()));
     EXPECT_CALL(*dns_sd_registry(),
                 AddObserver(MDnsAPI::Get(browser_context())))
         .Times(1);
-    MDnsAPI::Get(browser_context())->SetDnsSdRegistryForTesting(
-        scoped_ptr<DnsSdRegistry>(registry_));
+    MDnsAPI::Get(browser_context())
+        ->SetDnsSdRegistryForTesting(std::unique_ptr<DnsSdRegistry>(registry_));
 
     render_process_host_.reset(
         new content::MockRenderProcessHost(browser_context()));
   }
 
   // Returns the mDNS API factory function (mock vs. real) to use for the test.
   virtual BrowserContextKeyedServiceFactory::TestingFactoryFunction
   GetMDnsFactory() {
     return MDnsAPITestingFactoryFunction;
   }
@@ skipping 38 matching lines @@
 
   content::RenderProcessHost* render_process_host() const {
     return render_process_host_.get();
   }
 
  private:
   // The registry is owned by MDnsAPI, but MDnsAPI does not have an accessor
   // for it, so use a private member.
   MockDnsSdRegistry* registry_;
 
-  scoped_ptr<content::RenderProcessHost> render_process_host_;
+  std::unique_ptr<content::RenderProcessHost> render_process_host_;
 };
 
 class MDnsAPIMaxServicesTest : public MDnsAPITest {
  public:
   MockEventRouter* event_router() {
     return static_cast<MockEventRouter*>(EventRouter::Get(browser_context()));
   }
 };
 
 class MDnsAPIDiscoveryTest : public MDnsAPITest {
@@ skipping 155 matching lines @@
                                  render_process_host(), kExtId, filter, false);
 
   EXPECT_CALL(*dns_sd_registry(), UnregisterDnsSdListener("_trex._tcp.local"));
   EventRouter::Get(browser_context())
       ->RemoveFilteredEventListener(api::mdns::OnServiceList::kEventName,
                                     render_process_host(), kExtId, filter,
                                     false);
 }
 
 }  // namespace extensions