Use unique_ptr for Create{ServiceWorkerNetworkProvider,ApplicationCacheHost}

content/renderer/service_worker/service_worker_context_client.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 "content/renderer/service_worker/service_worker_context_client.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 
@@ skipping 1045 matching lines @@
     int payment_request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   DispatchPaymentRequestEventCallback callback =
       std::move(context_->payment_request_event_callbacks[payment_request_id]);
   std::move(callback).Run(EventResultToStatus(result),
                           base::Time::FromDoubleT(event_dispatch_time));
   context_->payment_request_event_callbacks.erase(payment_request_id);
 }
 
-blink::WebServiceWorkerNetworkProvider*
+std::unique_ptr<blink::WebServiceWorkerNetworkProvider>
 ServiceWorkerContextClient::CreateServiceWorkerNetworkProvider() {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
 
   // Create a content::ServiceWorkerNetworkProvider for this data source so
   // we can observe its requests.
   std::unique_ptr<ServiceWorkerNetworkProvider> provider =
       base::MakeUnique<ServiceWorkerNetworkProvider>(
           MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
           true /* is_parent_frame_secure */);
   provider_context_ = provider->context();
   network_provider_id_ = provider->provider_id();
 
   // Tell the network provider about which version to load.
   provider->SetServiceWorkerVersionId(service_worker_version_id_,
                                       embedded_worker_id_);
 
   // Blink is responsible for deleting the returned object.
-  return new WebServiceWorkerNetworkProviderImpl(std::move(provider));
+  return base::MakeUnique<WebServiceWorkerNetworkProviderImpl>(
+      std::move(provider));
 }
 
 std::unique_ptr<blink::WebWorkerFetchContext>
 ServiceWorkerContextClient::CreateServiceWorkerFetchContext() {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(base::FeatureList::IsEnabled(features::kOffMainThreadFetch));
   mojom::WorkerURLLoaderFactoryProviderPtr worker_url_loader_factory_provider;
   RenderThreadImpl::current()
       ->blink_platform_impl()
       ->GetInterfaceProvider()
       ->GetInterface(mojo::MakeRequest(&worker_url_loader_factory_provider));
 
   // Blink is responsible for deleting the returned object.
   return base::MakeUnique<ServiceWorkerFetchContextImpl>(
       worker_url_loader_factory_provider.PassInterface(), network_provider_id_);
 }
 
-blink::WebServiceWorkerProvider*
+std::unique_ptr<blink::WebServiceWorkerProvider>
 ServiceWorkerContextClient::CreateServiceWorkerProvider() {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(provider_context_);
 
   // Blink is responsible for deleting the returned object.
-  return new WebServiceWorkerProviderImpl(
+  return base::MakeUnique<WebServiceWorkerProviderImpl>(
       sender_.get(), provider_context_.get());
 }
 
 void ServiceWorkerContextClient::PostMessageToClient(
     const blink::WebString& uuid,
     const blink::WebString& message,
     blink::WebMessagePortChannelArray channels) {
   Send(new ServiceWorkerHostMsg_PostMessageToClient(
       GetRoutingID(), uuid.Utf8(), message.Utf16(),
       WebMessagePortChannelImpl::ExtractMessagePorts(std::move(channels))));
@@ skipping 534 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content