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

content/browser/service_worker/service_worker_version_unittest.cc

 // Copyright 2014 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 "content/browser/service_worker/service_worker_version.h"
 
 #include <stdint.h>
 #include <tuple>
 
 #include "base/macros.h"
@@ skipping 228 matching lines @@
     ASSERT_EQ(SERVICE_WORKER_OK, status);
 
     // Simulate adding one process to the pattern.
     helper_->SimulateAddProcessToPattern(pattern_,
                                          helper_->mock_render_process_id());
     ASSERT_TRUE(helper_->context()->process_manager()
         ->PatternHasProcessToRun(pattern_));
   }
 
   virtual std::unique_ptr<MessageReceiver> GetMessageReceiver() {
-    return base::WrapUnique(new MessageReceiver());
+    return base::MakeUnique<MessageReceiver>();
   }
 
   void TearDown() override {
     version_ = 0;
     registration_ = 0;
     helper_.reset();
   }
 
   void SimulateDispatchEvent(ServiceWorkerMetrics::EventType event_type) {
     ServiceWorkerStatusCode status =
@@ skipping 68 matching lines @@
   ServiceWorkerFailToStartTest()
       : ServiceWorkerVersionTest() {}
 
   void set_start_mode(MessageReceiverDisallowStart::StartMode mode) {
     MessageReceiverDisallowStart* helper =
         static_cast<MessageReceiverDisallowStart*>(helper_.get());
     helper->set_start_mode(mode);
   }
 
   std::unique_ptr<MessageReceiver> GetMessageReceiver() override {
-    return base::WrapUnique(new MessageReceiverDisallowStart());
+    return base::MakeUnique<MessageReceiverDisallowStart>();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFailToStartTest);
 };
 
 class MessageReceiverDisallowStop : public MessageReceiver {
  public:
   MessageReceiverDisallowStop() : MessageReceiver() {}
   ~MessageReceiverDisallowStop() override {}
 
   void OnStopWorker(int embedded_worker_id) override {
     // Do nothing.
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStop);
 };
 
 class ServiceWorkerStallInStoppingTest : public ServiceWorkerVersionTest {
  protected:
   ServiceWorkerStallInStoppingTest() : ServiceWorkerVersionTest() {}
 
   std::unique_ptr<MessageReceiver> GetMessageReceiver() override {
-    return base::WrapUnique(new MessageReceiverDisallowStop());
+    return base::MakeUnique<MessageReceiverDisallowStop>();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStallInStoppingTest);
 };
 
 class MessageReceiverMojoTestService : public MessageReceiver {
  public:
   MessageReceiverMojoTestService() : MessageReceiver() {}
   ~MessageReceiverMojoTestService() override {}
 
   void OnSetupMojo(shell::InterfaceRegistry* registry) override {
     registry->AddInterface(base::Bind(&TestMojoServiceImpl::Create));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MessageReceiverMojoTestService);
 };
 
 class ServiceWorkerVersionWithMojoTest : public ServiceWorkerVersionTest {
  protected:
   ServiceWorkerVersionWithMojoTest() : ServiceWorkerVersionTest() {}
 
   std::unique_ptr<MessageReceiver> GetMessageReceiver() override {
-    return base::WrapUnique(new MessageReceiverMojoTestService());
+    return base::MakeUnique<MessageReceiverMojoTestService>();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionWithMojoTest);
 };
 
 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   // Call StartWorker() multiple times.
   ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED;
@@ skipping 1338 matching lines @@
   histogram_tester_.ExpectTotalCount(kLinkMouseDown, 1);
   histogram_tester_.ExpectTotalCount(kLinkTapDown, 0);
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   StopWorker();
   // The UMA for kLinkMouseDown must be recorded when the worker stopped.
   histogram_tester_.ExpectTotalCount(kLinkMouseDown, 1);
   histogram_tester_.ExpectTotalCount(kLinkTapDown, 1);
 }
 
 }  // namespace content