Convert //android_webview to use std::unique_ptr

android_webview/native/aw_contents_io_thread_client_impl.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/native/aw_contents_io_thread_client_impl.h"
 
 #include <map>
+#include <memory>
 #include <utility>
 
 #include "android_webview/common/devtools_instrumentation.h"
 #include "android_webview/native/aw_contents_background_thread_client.h"
 #include "android_webview/native/aw_web_resource_response_impl.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/lazy_instance.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "jni/AwContentsIoThreadClient_jni.h"
 #include "net/base/net_errors.h"
@@ skipping 173 matching lines @@
     jstringArray_header_names = ToJavaArrayOfStrings(env, header_names);
     jstringArray_header_values = ToJavaArrayOfStrings(env, header_values);
   }
 };
 
 } // namespace
 
 // AwContentsIoThreadClientImpl -----------------------------------------------
 
 // static
-scoped_ptr<AwContentsIoThreadClient>
-AwContentsIoThreadClient::FromID(int render_process_id, int render_frame_id) {
+std::unique_ptr<AwContentsIoThreadClient> AwContentsIoThreadClient::FromID(
+    int render_process_id,
+    int render_frame_id) {
   pair<int, int> rfh_id(render_process_id, render_frame_id);
   IoThreadClientData client_data;
   if (!RfhToIoThreadClientMap::GetInstance()->Get(rfh_id, &client_data))
-    return scoped_ptr<AwContentsIoThreadClient>();
+    return std::unique_ptr<AwContentsIoThreadClient>();
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> java_delegate =
       client_data.io_thread_client.get(env);
   DCHECK(!client_data.pending_association || java_delegate.is_null());
-  return scoped_ptr<AwContentsIoThreadClient>(new AwContentsIoThreadClientImpl(
-      client_data.pending_association, java_delegate));
+  return std::unique_ptr<AwContentsIoThreadClient>(
+      new AwContentsIoThreadClientImpl(client_data.pending_association,
+                                       java_delegate));
 }
 
 // static
 void AwContentsIoThreadClient::SubFrameCreated(int render_process_id,
                                                int parent_render_frame_id,
                                                int child_render_frame_id) {
   pair<int, int> parent_rfh_id(render_process_id, parent_render_frame_id);
   pair<int, int> child_rfh_id(render_process_id, child_render_frame_id);
   IoThreadClientData client_data;
   if (!RfhToIoThreadClientMap::GetInstance()->Get(parent_rfh_id,
@@ skipping 28 matching lines @@
     const base::android::JavaRef<jobject>& jclient,
     const base::android::JavaRef<jobject>& browser_context) {
   // TODO: currently there is only one browser context so it is ok to
   // store in a global variable, in the future use browser_context to
   // obtain the correct instance.
   JavaObjectWeakGlobalRef temp(AttachCurrentThread(), jclient.obj());
   g_sw_instance_.Get() = temp;
 }
 
 // static
-scoped_ptr<AwContentsIoThreadClient>
+std::unique_ptr<AwContentsIoThreadClient>
 AwContentsIoThreadClient::GetServiceWorkerIoThreadClient() {
   if (g_sw_instance_.Get().is_empty())
-    return scoped_ptr<AwContentsIoThreadClient>();
+    return std::unique_ptr<AwContentsIoThreadClient>();
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> java_delegate = g_sw_instance_.Get().get(env);
 
   DCHECK(!java_delegate.is_null());
-  return scoped_ptr<AwContentsIoThreadClient>(new AwContentsIoThreadClientImpl(
-      false, java_delegate));
+  return std::unique_ptr<AwContentsIoThreadClient>(
+      new AwContentsIoThreadClientImpl(false, java_delegate));
 }
 
 AwContentsIoThreadClientImpl::AwContentsIoThreadClientImpl(
     bool pending_association,
     const JavaRef<jobject>& obj)
   : pending_association_(pending_association),
     java_object_(obj) {
 }
 
 AwContentsIoThreadClientImpl::~AwContentsIoThreadClientImpl() {
@@ skipping 12 matching lines @@
 
   JNIEnv* env = AttachCurrentThread();
   return static_cast<AwContentsIoThreadClient::CacheMode>(
       Java_AwContentsIoThreadClient_getCacheMode(
           env, java_object_.obj()));
 }
 
 
 namespace {
 
-scoped_ptr<AwWebResourceResponse> RunShouldInterceptRequest(
+std::unique_ptr<AwWebResourceResponse> RunShouldInterceptRequest(
     WebResourceRequest web_request,
     JavaObjectWeakGlobalRef ref) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   JNIEnv* env = AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> obj = ref.get(env);
   if (obj.is_null())
     return nullptr;
 
   web_request.ConvertToJava(env);
 
   devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
       "shouldInterceptRequest");
   ScopedJavaLocalRef<jobject> ret =
       AwContentsBackgroundThreadClient::shouldInterceptRequest(
           env,
           obj.obj(),
           web_request.jstring_url.obj(),
           web_request.is_main_frame,
           web_request.has_user_gesture,
           web_request.jstring_method.obj(),
           web_request.jstringArray_header_names.obj(),
           web_request.jstringArray_header_values.obj());
-  return scoped_ptr<AwWebResourceResponse>(
+  return std::unique_ptr<AwWebResourceResponse>(
       ret.is_null() ? nullptr : new AwWebResourceResponseImpl(ret));
 }
 
-scoped_ptr<AwWebResourceResponse> ReturnNull() {
-  return scoped_ptr<AwWebResourceResponse>();
+std::unique_ptr<AwWebResourceResponse> ReturnNull() {
+  return std::unique_ptr<AwWebResourceResponse>();
 }
 
 }  // namespace
 
 void AwContentsIoThreadClientImpl::ShouldInterceptRequestAsync(
     const net::URLRequest* request,
     const ShouldInterceptRequestResultCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  base::Callback<scoped_ptr<AwWebResourceResponse>()> get_response =
+  base::Callback<std::unique_ptr<AwWebResourceResponse>()> get_response =
       base::Bind(&ReturnNull);
   JNIEnv* env = AttachCurrentThread();
   if (bg_thread_client_object_.is_null() && !java_object_.is_null()) {
     bg_thread_client_object_.Reset(
         Java_AwContentsIoThreadClient_getBackgroundThreadClient(
             env, java_object_.obj()));
   }
   if (!bg_thread_client_object_.is_null()) {
     get_response = base::Bind(
         &RunShouldInterceptRequest, WebResourceRequest(request),
@@ skipping 169 matching lines @@
       jstring_reason.obj(),
       jstringArray_response_header_names.obj(),
       jstringArray_response_header_values.obj());
 }
 
 bool RegisterAwContentsIoThreadClientImpl(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 } // namespace android_webview