Convert //android_webview to use std::unique_ptr

android_webview/native/cookie_manager.cc

 // Copyright (c) 2011 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/cookie_manager.h"
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_cookie_access_policy.h"
 #include "android_webview/browser/net/init_native_callback.h"
 #include "android_webview/browser/scoped_allow_wait_for_legacy_web_view_api.h"
 #include "android_webview/native/aw_browser_dependency_factory.h"
 #include "base/android/jni_string.h"
 #include "base/android/path_utils.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
@@ skipping 40 matching lines @@
 
   void Invoke(bool result) {
     if (!callback_.is_null()) {
       JNIEnv* env = base::android::AttachCurrentThread();
       Java_AwCookieManager_invokeBooleanCookieCallback(env, callback_.obj(),
                                                        result);
     }
   }
 
   static BoolCallback ConvertToCallback(
-      scoped_ptr<BoolCookieCallbackHolder> me) {
+      std::unique_ptr<BoolCookieCallbackHolder> me) {
     return base::Bind(&BoolCookieCallbackHolder::Invoke,
                       base::Owned(me.release()));
   }
 
  private:
   ScopedJavaGlobalRef<jobject> callback_;
   DISALLOW_COPY_AND_ASSIGN(BoolCookieCallbackHolder);
 };
 
 // Construct a closure which signals a waitable event if and when the closure
@@ skipping 63 matching lines @@
   // Returns the TaskRunner on which the CookieStore lives.
   base::SingleThreadTaskRunner* GetCookieStoreTaskRunner();
   // Returns the CookieStore, creating it if necessary. This must only be called
   // on the CookieStore TaskRunner.
   net::CookieStore* GetCookieStore();
 
   void SetShouldAcceptCookies(bool accept);
   bool GetShouldAcceptCookies();
   void SetCookie(const GURL& host,
                  const std::string& cookie_value,
-                 scoped_ptr<BoolCookieCallbackHolder> callback);
+                 std::unique_ptr<BoolCookieCallbackHolder> callback);
   void SetCookieSync(const GURL& host, const std::string& cookie_value);
   std::string GetCookie(const GURL& host);
-  void RemoveSessionCookies(scoped_ptr<BoolCookieCallbackHolder> callback);
-  void RemoveAllCookies(scoped_ptr<BoolCookieCallbackHolder> callback);
+  void RemoveSessionCookies(std::unique_ptr<BoolCookieCallbackHolder> callback);
+  void RemoveAllCookies(std::unique_ptr<BoolCookieCallbackHolder> callback);
   void RemoveAllCookiesSync();
   void RemoveSessionCookiesSync();
   void RemoveExpiredCookies();
   void FlushCookieStore();
   bool HasCookies();
   bool AllowFileSchemeCookies();
   void SetAcceptFileSchemeCookies(bool accept);
 
  private:
   friend struct base::DefaultLazyInstanceTraits<CookieManager>;
@@ skipping 34 matching lines @@
   // to creating the CookieStore.
   bool accept_file_scheme_cookies_;
   // True once the cookie store has been created. Just used to track when
   // |accept_file_scheme_cookies_| can no longer be modified.
   bool cookie_store_created_;
 
   base::Thread cookie_store_client_thread_;
   base::Thread cookie_store_backend_thread_;
 
   scoped_refptr<base::SingleThreadTaskRunner> cookie_store_task_runner_;
-  scoped_ptr<net::CookieStore> cookie_store_;
+  std::unique_ptr<net::CookieStore> cookie_store_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieManager);
 };
 
 base::LazyInstance<CookieManager>::Leaky g_lazy_instance;
 
 }  // namespace
 
 // static
 CookieManager* CookieManager::GetInstance() {
@@ skipping 110 matching lines @@
   AwCookieAccessPolicy::GetInstance()->SetShouldAcceptCookies(accept);
 }
 
 bool CookieManager::GetShouldAcceptCookies() {
   return AwCookieAccessPolicy::GetInstance()->GetShouldAcceptCookies();
 }
 
 void CookieManager::SetCookie(
     const GURL& host,
     const std::string& cookie_value,
-    scoped_ptr<BoolCookieCallbackHolder> callback_holder) {
+    std::unique_ptr<BoolCookieCallbackHolder> callback_holder) {
   BoolCallback callback =
       BoolCookieCallbackHolder::ConvertToCallback(std::move(callback_holder));
   ExecCookieTask(base::Bind(&CookieManager::SetCookieHelper,
                             base::Unretained(this),
                             host,
                             cookie_value,
                             callback));
 }
 
 void CookieManager::SetCookieSync(const GURL& host,
@@ skipping 36 matching lines @@
 }
 
 void CookieManager::GetCookieValueCompleted(base::Closure complete,
                                             std::string* result,
                                             const std::string& value) {
   *result = value;
   complete.Run();
 }
 
 void CookieManager::RemoveSessionCookies(
-    scoped_ptr<BoolCookieCallbackHolder> callback_holder) {
+    std::unique_ptr<BoolCookieCallbackHolder> callback_holder) {
   BoolCallback callback =
       BoolCookieCallbackHolder::ConvertToCallback(std::move(callback_holder));
   ExecCookieTask(base::Bind(&CookieManager::RemoveSessionCookiesHelper,
                             base::Unretained(this),
                             callback));
 }
 
 void CookieManager::RemoveSessionCookiesSync() {
   ExecCookieTaskSync(base::Bind(&CookieManager::RemoveSessionCookiesHelper,
                             base::Unretained(this)));
 }
 
 void CookieManager::RemoveSessionCookiesHelper(
     BoolCallback callback) {
   GetCookieStore()->DeleteSessionCookiesAsync(
       base::Bind(&CookieManager::RemoveCookiesCompleted, base::Unretained(this),
                  callback));
 }
 
 void CookieManager::RemoveCookiesCompleted(
     BoolCallback callback,
     int num_deleted) {
   callback.Run(num_deleted > 0);
 }
 
 void CookieManager::RemoveAllCookies(
-    scoped_ptr<BoolCookieCallbackHolder> callback_holder) {
+    std::unique_ptr<BoolCookieCallbackHolder> callback_holder) {
   BoolCallback callback =
       BoolCookieCallbackHolder::ConvertToCallback(std::move(callback_holder));
   ExecCookieTask(base::Bind(&CookieManager::RemoveAllCookiesHelper,
                             base::Unretained(this),
                             callback));
 }
 
 void CookieManager::RemoveAllCookiesSync() {
   ExecCookieTaskSync(base::Bind(&CookieManager::RemoveAllCookiesHelper,
                             base::Unretained(this)));
@@ skipping 68 matching lines @@
   return CookieManager::GetInstance()->GetShouldAcceptCookies();
 }
 
 static void SetCookie(JNIEnv* env,
                       const JavaParamRef<jobject>& obj,
                       const JavaParamRef<jstring>& url,
                       const JavaParamRef<jstring>& value,
                       const JavaParamRef<jobject>& java_callback) {
   GURL host(ConvertJavaStringToUTF16(env, url));
   std::string cookie_value(ConvertJavaStringToUTF8(env, value));
-  scoped_ptr<BoolCookieCallbackHolder> callback(
+  std::unique_ptr<BoolCookieCallbackHolder> callback(
       new BoolCookieCallbackHolder(env, java_callback));
   CookieManager::GetInstance()->SetCookie(host, cookie_value,
                                           std::move(callback));
 }
 
 static void SetCookieSync(JNIEnv* env,
                           const JavaParamRef<jobject>& obj,
                           const JavaParamRef<jstring>& url,
                           const JavaParamRef<jstring>& value) {
   GURL host(ConvertJavaStringToUTF16(env, url));
   std::string cookie_value(ConvertJavaStringToUTF8(env, value));
 
   CookieManager::GetInstance()->SetCookieSync(host, cookie_value);
 }
 
 static ScopedJavaLocalRef<jstring> GetCookie(JNIEnv* env,
                                              const JavaParamRef<jobject>& obj,
                                              const JavaParamRef<jstring>& url) {
   GURL host(ConvertJavaStringToUTF16(env, url));
 
   return base::android::ConvertUTF8ToJavaString(
       env, CookieManager::GetInstance()->GetCookie(host));
 }
 
 static void RemoveSessionCookies(JNIEnv* env,
                                  const JavaParamRef<jobject>& obj,
                                  const JavaParamRef<jobject>& java_callback) {
-  scoped_ptr<BoolCookieCallbackHolder> callback(
+  std::unique_ptr<BoolCookieCallbackHolder> callback(
       new BoolCookieCallbackHolder(env, java_callback));
   CookieManager::GetInstance()->RemoveSessionCookies(std::move(callback));
 }
 
 static void RemoveSessionCookiesSync(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
     CookieManager::GetInstance()->RemoveSessionCookiesSync();
 }
 
 static void RemoveAllCookies(JNIEnv* env,
                              const JavaParamRef<jobject>& obj,
                              const JavaParamRef<jobject>& java_callback) {
-  scoped_ptr<BoolCookieCallbackHolder> callback(
+  std::unique_ptr<BoolCookieCallbackHolder> callback(
       new BoolCookieCallbackHolder(env, java_callback));
   CookieManager::GetInstance()->RemoveAllCookies(std::move(callback));
 }
 
 static void RemoveAllCookiesSync(JNIEnv* env,
                                  const JavaParamRef<jobject>& obj) {
   CookieManager::GetInstance()->RemoveAllCookiesSync();
 }
 
 static void RemoveExpiredCookies(JNIEnv* env,
@@ skipping 30 matching lines @@
 
 net::CookieStore* GetCookieStore() {
   return CookieManager::GetInstance()->GetCookieStore();
 }
 
 bool RegisterCookieManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // android_webview namespace