Use unique_ptr for Create{ServiceWorkerNetworkProvider,ApplicationCacheHost}

content/renderer/render_frame_impl.cc

 // Copyright 2013 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/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 2983 matching lines @@
       std::move(factory_selector), url_index_, std::move(params));
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   media_player->SetMediaPlayerManager(GetMediaPlayerManager());
   media_player->SetDeviceScaleFactor(render_view_->GetDeviceScaleFactor());
 #endif  // defined(OS_ANDROID)
 
   return media_player;
 }
 
-blink::WebApplicationCacheHost* RenderFrameImpl::CreateApplicationCacheHost(
+std::unique_ptr<blink::WebApplicationCacheHost>
+RenderFrameImpl::CreateApplicationCacheHost(
     blink::WebApplicationCacheHostClient* client) {
   if (!frame_ || !frame_->View())
-    return NULL;
+    return nullptr;
 
   DocumentState* document_state =
       frame_->ProvisionalDataSource()
           ? DocumentState::FromDataSource(frame_->ProvisionalDataSource())
           : DocumentState::FromDataSource(frame_->DataSource());
 
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
 
-  return new RendererWebApplicationCacheHostImpl(
+  return base::MakeUnique<RendererWebApplicationCacheHostImpl>(
       RenderViewImpl::FromWebView(frame_->View()), client,
       RenderThreadImpl::current()->appcache_dispatcher()->backend_proxy(),
       navigation_state->request_params().appcache_host_id);
 }
 
 blink::WebWorkerContentSettingsClientProxy*
 RenderFrameImpl::CreateWorkerContentSettingsClientProxy() {
   if (!frame_ || !frame_->View())
     return NULL;
   return GetContentClient()->renderer()->CreateWorkerContentSettingsClientProxy(
@@ skipping 52 matching lines @@
 
 blink::WebCookieJar* RenderFrameImpl::CookieJar() {
   return &cookie_jar_;
 }
 
 blink::BlameContext* RenderFrameImpl::GetFrameBlameContext() {
   DCHECK(blame_context_);
   return blame_context_.get();
 }
 
-blink::WebServiceWorkerProvider*
+std::unique_ptr<blink::WebServiceWorkerProvider>
 RenderFrameImpl::CreateServiceWorkerProvider() {
   // At this point we should have non-null data source.
   DCHECK(frame_->DataSource());
   if (!ChildThreadImpl::current())
     return nullptr;  // May be null in some tests.
   ServiceWorkerNetworkProvider* provider =
       ServiceWorkerNetworkProvider::FromWebServiceWorkerNetworkProvider(
           frame_->DataSource()->GetServiceWorkerNetworkProvider());
   if (!provider->context()) {
     // The context can be null when the frame is sandboxed.
     return nullptr;
   }
-  return new WebServiceWorkerProviderImpl(
+  return base::MakeUnique<WebServiceWorkerProviderImpl>(
       ChildThreadImpl::current()->thread_safe_sender(), provider->context());
 }
 
 void RenderFrameImpl::DidAccessInitialDocument() {
   DCHECK(!frame_->Parent());
   // NOTE: Do not call back into JavaScript here, since this call is made from a
   // V8 security check.
 
   // If the request hasn't yet committed, notify the browser process that it is
   // no longer safe to show the pending URL of the main frame, since a URL spoof
@@ skipping 3925 matching lines @@
       policy(info.default_policy),
       replaces_current_history_item(info.replaces_current_history_item),
       history_navigation_in_new_child_frame(
           info.is_history_navigation_in_new_child_frame),
       client_redirect(info.is_client_redirect),
       cache_disabled(info.is_cache_disabled),
       form(info.form),
       source_location(info.source_location) {}
 
 }  // namespace content