Convert //android_webview to use std::unique_ptr

android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.cc

 // Copyright (c) 2012 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 "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
 
+#include <memory>
 #include <string>
 
 #include "android_webview/browser/aw_contents_io_thread_client.h"
 #include "android_webview/browser/aw_login_delegate.h"
 #include "android_webview/browser/aw_resource_context.h"
 #include "android_webview/common/url_constants.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "components/auto_login_parser/auto_login_parser.h"
 #include "components/navigation_interception/intercept_navigation_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/resource_dispatcher_host_login_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/resource_throttle.h"
 #include "net/base/load_flags.h"
@@ skipping 49 matching lines @@
   const char* GetNameForLogging() const override;
 
   void OnIoThreadClientReady(int new_render_process_id,
                              int new_render_frame_id);
   bool MaybeBlockRequest();
   bool ShouldBlockRequest();
   int render_process_id() const { return render_process_id_; }
   int render_frame_id() const { return render_frame_id_; }
 
  private:
-  scoped_ptr<AwContentsIoThreadClient> GetIoThreadClient() const;
+  std::unique_ptr<AwContentsIoThreadClient> GetIoThreadClient() const;
 
   int render_process_id_;
   int render_frame_id_;
   net::URLRequest* request_;
 };
 
 IoThreadClientThrottle::IoThreadClientThrottle(int render_process_id,
                                                int render_frame_id,
                                                net::URLRequest* request)
     : render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
       request_(request) { }
 
 IoThreadClientThrottle::~IoThreadClientThrottle() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   g_webview_resource_dispatcher_host_delegate.Get().
       RemovePendingThrottleOnIoThread(this);
 }
 
 const char* IoThreadClientThrottle::GetNameForLogging() const {
   return "IoThreadClientThrottle";
 }
 
-scoped_ptr<AwContentsIoThreadClient>
+std::unique_ptr<AwContentsIoThreadClient>
 IoThreadClientThrottle::GetIoThreadClient() const {
   if (content::ResourceRequestInfo::OriginatedFromServiceWorker(request_))
     return AwContentsIoThreadClient::GetServiceWorkerIoThreadClient();
 
   return AwContentsIoThreadClient::FromID(render_process_id_, render_frame_id_);
 }
 
 void IoThreadClientThrottle::WillStartRequest(bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // valid render_frame_id_ implies nonzero render_processs_id_
   DCHECK((render_frame_id_ < 1) || (render_process_id_ != 0));
   *defer = false;
 
   // Defer all requests of a pop up that is still not associated with Java
   // client so that the client will get a chance to override requests.
-  scoped_ptr<AwContentsIoThreadClient> io_client = GetIoThreadClient();
+  std::unique_ptr<AwContentsIoThreadClient> io_client = GetIoThreadClient();
   if (io_client && io_client->PendingAssociation()) {
     *defer = true;
     AwResourceDispatcherHostDelegate::AddPendingThrottle(
         render_process_id_, render_frame_id_, this);
   } else {
     MaybeBlockRequest();
   }
 }
 
 void IoThreadClientThrottle::WillRedirectRequest(
@@ skipping 13 matching lines @@
 
 bool IoThreadClientThrottle::MaybeBlockRequest() {
   if (ShouldBlockRequest()) {
     controller()->CancelWithError(net::ERR_ACCESS_DENIED);
     return true;
   }
   return false;
 }
 
 bool IoThreadClientThrottle::ShouldBlockRequest() {
-  scoped_ptr<AwContentsIoThreadClient> io_client = GetIoThreadClient();
+  std::unique_ptr<AwContentsIoThreadClient> io_client = GetIoThreadClient();
   if (!io_client)
     return false;
 
   // Part of implementation of WebSettings.allowContentAccess.
   if (request_->url().SchemeIs(url::kContentScheme) &&
       io_client->ShouldBlockContentUrls()) {
     return true;
   }
 
   // Part of implementation of WebSettings.allowFileAccess.
@@ skipping 70 matching lines @@
     content::ResourceContext* resource_context,
     content::ResourceResponse* response) {
   AddExtraHeadersIfNeeded(request, resource_context);
 }
 
 void AwResourceDispatcherHostDelegate::RequestComplete(
     net::URLRequest* request) {
   if (request && !request->status().is_success()) {
     const content::ResourceRequestInfo* request_info =
         content::ResourceRequestInfo::ForRequest(request);
-    scoped_ptr<AwContentsIoThreadClient> io_client =
+    std::unique_ptr<AwContentsIoThreadClient> io_client =
         AwContentsIoThreadClient::FromID(request_info->GetChildID(),
                                          request_info->GetRenderFrameID());
     if (io_client) {
       io_client->OnReceivedError(request);
     } else {
       DLOG(WARNING) << "io_client is null, onReceivedError dropped for " <<
           request->url();
     }
   }
 }
@@ skipping 23 matching lines @@
     response_headers->GetNormalizedHeader("content-disposition",
         &content_disposition);
     response_headers->GetMimeType(&mime_type);
   }
 
   request->Cancel();
 
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(request);
 
-  scoped_ptr<AwContentsIoThreadClient> io_client =
-      AwContentsIoThreadClient::FromID(
-          child_id, request_info->GetRenderFrameID());
+  std::unique_ptr<AwContentsIoThreadClient> io_client =
+      AwContentsIoThreadClient::FromID(child_id,
+                                       request_info->GetRenderFrameID());
 
   // POST request cannot be repeated in general, so prevent client from
   // retrying the same request, even if it is with a GET.
   if ("GET" == request->method() && io_client) {
     io_client->NewDownload(url,
                            user_agent,
                            content_disposition,
                            mime_type,
                            content_length);
   }
@@ skipping 30 matching lines @@
     DLOG(FATAL) << "Started request without associated info: " <<
         request->url();
     return;
   }
 
   if (request_info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME) {
     // Check for x-auto-login header.
     auto_login_parser::HeaderData header_data;
     if (auto_login_parser::ParserHeaderInResponse(
             request, auto_login_parser::ALLOW_ANY_REALM, &header_data)) {
-      scoped_ptr<AwContentsIoThreadClient> io_client =
+      std::unique_ptr<AwContentsIoThreadClient> io_client =
           AwContentsIoThreadClient::FromID(request_info->GetChildID(),
                                            request_info->GetRenderFrameID());
       if (io_client) {
         io_client->NewLoginRequest(
             header_data.realm, header_data.account, header_data.args);
       }
     }
   }
 }
 
@@ skipping 82 matching lines @@
       net::HttpRequestHeaders headers;
       headers.AddHeadersFromString(extra_headers);
       for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext(); ) {
         request->SetExtraRequestHeaderByName(it.name(), it.value(), false);
       }
     }
   }
 }
 
 }  // namespace android_webview