Convert //android_webview to use std::unique_ptr

android_webview/browser/net/aw_cookie_store_wrapper.cc

 // Copyright 2016 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/net/aw_cookie_store_wrapper.h"
 
 #include <string>
 
 #include "android_webview/browser/net/init_native_callback.h"
 #include "base/memory/ref_counted_delete_on_message_loop.h"
@@ skipping 11 matching lines @@
 
 // Wraps a subscription to cookie change notifications for the global
 // CookieStore for a consumer that lives on another thread. Handles passing
 // messages between thread, and destroys itself when the consumer unsubscribes.
 // Must be created on the consumer's thread. Each instance only supports a
 // single subscription.
 class SubscriptionWrapper {
  public:
   SubscriptionWrapper() : weak_factory_(this) {}
 
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> Subscribe(
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> Subscribe(
       const GURL& url,
       const std::string& name,
       const net::CookieStore::CookieChangedCallback& callback) {
     // This class is only intended to be used for a single subscription.
     DCHECK(callback_list_.empty());
 
     nested_subscription_ =
         new NestedSubscription(url, name, weak_factory_.GetWeakPtr());
     return callback_list_.Add(callback);
   }
@@ skipping 29 matching lines @@
 
     void OnChanged(const net::CanonicalCookie& cookie, bool removed) {
       client_task_runner_->PostTask(
           FROM_HERE, base::Bind(&SubscriptionWrapper::OnChanged,
                                 subscription_wrapper_, cookie, removed));
     }
 
     base::WeakPtr<SubscriptionWrapper> subscription_wrapper_;
     scoped_refptr<base::TaskRunner> client_task_runner_;
 
-    scoped_ptr<net::CookieStore::CookieChangedSubscription> subscription_;
+    std::unique_ptr<net::CookieStore::CookieChangedSubscription> subscription_;
 
     DISALLOW_COPY_AND_ASSIGN(NestedSubscription);
   };
 
   void OnChanged(const net::CanonicalCookie& cookie, bool removed) {
     callback_list_.Notify(cookie, removed);
   }
 
   // The "list" only had one entry, so can just clean up now.
   void OnUnsubscribe() { delete this; }
@@ skipping 218 matching lines @@
   PostTaskToCookieStoreTaskRunner(base::Bind(
       &FlushStoreOnCookieThread, CreateWrappedClosureCallback(callback)));
 }
 
 void AwCookieStoreWrapper::SetForceKeepSessionState() {
   DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&SetForceKeepSessionStateOnCookieThread));
 }
 
-scoped_ptr<net::CookieStore::CookieChangedSubscription>
+std::unique_ptr<net::CookieStore::CookieChangedSubscription>
 AwCookieStoreWrapper::AddCallbackForCookie(
     const GURL& url,
     const std::string& name,
     const CookieChangedCallback& callback) {
   DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
 
   // The SubscriptionWrapper is owned by the subscription itself, and has no
   // connection to the AwCookieStoreWrapper after creation. Other CookieStore
   // implementations DCHECK if a subscription outlasts the cookie store,
   // unfortunately, this design makes DCHECKing if there's an outstanding
@@ skipping 16 matching lines @@
                     base::Bind(&AwCookieStoreWrapper::RunClosureCallback,
                                weak_factory_.GetWeakPtr(), callback));
 }
 
 void AwCookieStoreWrapper::RunClosureCallback(const base::Closure& callback) {
   DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
   callback.Run();
 }
 
 }  // namespace android_webview