Re-write many calls to WrapUnique() with MakeUnique()

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>
@@ skipping 55 matching lines @@
   MOCK_CONST_METHOD2(IsMDnsAllowed,
                      bool(const std::string& extension_id,
                           const std::string& service_type));
 
   MOCK_METHOD0(GetEventListeners,
                const extensions::EventListenerMap::ListenerList&());
 };
 
 std::unique_ptr<KeyedService> MockedMDnsAPITestingFactoryFunction(
     content::BrowserContext* context) {
-  return base::WrapUnique(new MockedMDnsAPI(context));
+  return base::MakeUnique<MockedMDnsAPI>(context);
 }
 
 std::unique_ptr<KeyedService> MDnsAPITestingFactoryFunction(
     content::BrowserContext* context) {
-  return base::WrapUnique(new MDnsAPI(context));
+  return base::MakeUnique<MDnsAPI>(context);
 }
 
 std::unique_ptr<KeyedService> BuildEventRouter(
     content::BrowserContext* context) {
-  return base::WrapUnique(
-      new extensions::EventRouter(context, ExtensionPrefs::Get(context)));
+  return base::MakeUnique<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 24 matching lines @@
   virtual ~MockEventRouter() {}
 
   virtual void BroadcastEvent(std::unique_ptr<Event> event) {
     BroadcastEventPtr(event.get());
   }
   MOCK_METHOD1(BroadcastEventPtr, void(Event* event));
 };
 
 std::unique_ptr<KeyedService> MockEventRouterFactoryFunction(
     content::BrowserContext* context) {
-  return base::WrapUnique(
-      new MockEventRouter(context, ExtensionPrefs::Get(context)));
+  return base::MakeUnique<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,
                                testing::MatchResultListener* listener) const {
@@ skipping 295 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