Convert //android_webview to use std::unique_ptr

android_webview/native/aw_contents.cc

 // Copyright 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.h"
 
 #include <limits>
 #include <utility>
 
 #include "android_webview/browser/aw_browser_context.h"
@@ skipping 27 matching lines @@
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/locale_utils.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/memory_pressure_listener.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
 #include "base/supports_user_data.h"
 #include "components/autofill/content/browser/content_autofill_driver_factory.h"
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
 #include "components/navigation_interception/intercept_navigation_delegate.h"
 #include "content/public/browser/android/content_view_core.h"
@@ skipping 114 matching lines @@
 // static
 AwBrowserPermissionRequestDelegate* AwBrowserPermissionRequestDelegate::FromID(
     int render_process_id, int render_frame_id) {
   AwContents* aw_contents = AwContents::FromWebContents(
       content::WebContents::FromRenderFrameHost(
           content::RenderFrameHost::FromID(render_process_id,
                                            render_frame_id)));
   return aw_contents;
 }
 
-AwContents::AwContents(scoped_ptr<WebContents> web_contents)
+AwContents::AwContents(std::unique_ptr<WebContents> web_contents)
     : shared_renderer_state_(
-          this, BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
+          this,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
       browser_view_renderer_(
-          this, BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+          this,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisablePageVisibility)),
       web_contents_(std::move(web_contents)),
       renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()) {
   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
   browser_view_renderer_.SetSharedRendererState(&shared_renderer_state_);
   icon_helper_.reset(new IconHelper(web_contents_.get()));
   icon_helper_->SetListener(this);
   web_contents_->SetUserData(android_webview::kAwContentsUserDataKey,
                              new AwContentsUserData(this));
@@ skipping 32 matching lines @@
 
   contents_client_bridge_.reset(
       new AwContentsClientBridge(env, contents_client_bridge));
   AwContentsClientBridgeBase::Associate(web_contents_.get(),
                                         contents_client_bridge_.get());
 
   AwContentsIoThreadClientImpl::Associate(web_contents_.get(),
                                           io_thread_client);
 
   InterceptNavigationDelegate::Associate(
-      web_contents_.get(),
-      make_scoped_ptr(new InterceptNavigationDelegate(
-          env, intercept_navigation_delegate)));
+      web_contents_.get(), base::WrapUnique(new InterceptNavigationDelegate(
+                               env, intercept_navigation_delegate)));
 
   // Finally, having setup the associations, release any deferred requests
   for (content::RenderFrameHost* rfh : web_contents_->GetAllFrames()) {
     int render_process_id = rfh->GetProcess()->GetID();
     int render_frame_id = rfh->GetRoutingID();
     AwResourceDispatcherHostDelegate::OnIoThreadClientReady(render_process_id,
                                                             render_frame_id);
   }
 }
 
@@ skipping 68 matching lines @@
 void AwContents::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   java_ref_.reset();
   delete this;
 }
 
 static jlong Init(JNIEnv* env,
                   const JavaParamRef<jclass>&,
                   const JavaParamRef<jobject>& browser_context) {
   // TODO(joth): Use |browser_context| to get the native BrowserContext, rather
   // than hard-code the default instance lookup here.
-  scoped_ptr<WebContents> web_contents(content::WebContents::Create(
+  std::unique_ptr<WebContents> web_contents(content::WebContents::Create(
       content::WebContents::CreateParams(AwBrowserContext::GetDefault())));
   // Return an 'uninitialized' instance; most work is deferred until the
   // subsequent SetJavaPeers() call.
   return reinterpret_cast<intptr_t>(new AwContents(std::move(web_contents)));
 }
 
 static void SetForceAuxiliaryBitmapRendering(
     JNIEnv* env,
     const JavaParamRef<jclass>&,
     jboolean force_auxiliary_bitmap_rendering) {
@@ skipping 256 matching lines @@
                                         const JavaParamRef<jstring>& origin,
                                         jlong resources) {
   permission_request_handler_->PreauthorizePermission(
       GURL(base::android::ConvertJavaStringToUTF8(env, origin)), resources);
 }
 
 void AwContents::RequestProtectedMediaIdentifierPermission(
     const GURL& origin,
     const base::Callback<void(bool)>& callback) {
   permission_request_handler_->SendRequest(
-      scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
+      std::unique_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
           origin, AwPermissionRequest::ProtectedMediaId, callback)));
 }
 
 void AwContents::CancelProtectedMediaIdentifierPermissionRequests(
     const GURL& origin) {
   permission_request_handler_->CancelRequest(
       origin, AwPermissionRequest::ProtectedMediaId);
 }
 
 void AwContents::RequestGeolocationPermission(
     const GURL& origin,
     const base::Callback<void(bool)>& callback) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
     ShowGeolocationPrompt(origin, callback);
     return;
   }
   permission_request_handler_->SendRequest(
-      scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
+      std::unique_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
           origin, AwPermissionRequest::Geolocation, callback)));
 }
 
 void AwContents::CancelGeolocationPermissionRequests(const GURL& origin) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
     HideGeolocationPrompt(origin);
     return;
   }
   permission_request_handler_->CancelRequest(
       origin, AwPermissionRequest::Geolocation);
 }
 
 void AwContents::RequestMIDISysexPermission(
     const GURL& origin,
     const base::Callback<void(bool)>& callback) {
   permission_request_handler_->SendRequest(
-      scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
+      std::unique_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
           origin, AwPermissionRequest::MIDISysex, callback)));
 }
 
 void AwContents::CancelMIDISysexPermissionRequests(const GURL& origin) {
   permission_request_handler_->CancelRequest(
       origin, AwPermissionRequest::AwPermissionRequest::MIDISysex);
 }
 
 void AwContents::FindAllAsync(JNIEnv* env,
                               const JavaParamRef<jobject>& obj,
@@ skipping 305 matching lines @@
     TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_EmptySize",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   // TODO(hush): Right now webview size is passed in as the auxiliary bitmap
   // size, which might hurt performace (only for software draws with auxiliary
   // bitmap). For better performance, get global visible rect, transform it
   // from screen space to view space, then intersect with the webview in
   // viewspace.  Use the resulting rect as the auxiliary bitmap.
-  scoped_ptr<SoftwareCanvasHolder> canvas_holder = SoftwareCanvasHolder::Create(
-      canvas, scroll, view_size, g_force_auxiliary_bitmap_rendering);
+  std::unique_ptr<SoftwareCanvasHolder> canvas_holder =
+      SoftwareCanvasHolder::Create(canvas, scroll, view_size,
+                                   g_force_auxiliary_bitmap_rendering);
   if (!canvas_holder || !canvas_holder->GetCanvas()) {
     TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_NoSoftwareCanvas",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   return browser_view_renderer_.OnDrawSoftware(canvas_holder->GetCanvas());
 }
 
 void AwContents::SetPendingWebContentsForPopup(
-    scoped_ptr<content::WebContents> pending) {
+    std::unique_ptr<content::WebContents> pending) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (pending_contents_.get()) {
     // TODO(benm): Support holding multiple pop up window requests.
     LOG(WARNING) << "Blocking popup window creation as an outstanding "
                  << "popup window is still pending.";
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, pending.release());
     return;
   }
   pending_contents_.reset(new AwContents(std::move(pending)));
   // Set dip_scale for pending contents, which is necessary for the later
@@ skipping 302 matching lines @@
     const JavaParamRef<jobject>& obj) {
   web_contents_->ResumeLoadingCreatedWebContents();
 }
 
 void SetShouldDownloadFavicons(JNIEnv* env,
                                const JavaParamRef<jclass>& jclazz) {
   g_should_download_favicons = true;
 }
 
 }  // namespace android_webview