Convert //ios from scoped_ptr to std::unique_ptr.

ios/net/cookies/cookie_store_ios.mm

 // 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 "ios/net/cookies/cookie_store_ios.h"
 
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 
 #include "base/bind.h"
@@ skipping 309 matching lines @@
                                         : NSHTTPCookieAcceptPolicyNever;
   NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
   NSHTTPCookieAcceptPolicy current_policy = [store cookieAcceptPolicy];
   if (current_policy == policy)
     return;
   [store setCookieAcceptPolicy:policy];
   NotificationTrampoline::GetInstance()->NotifyCookiePolicyChanged();
 }
 
 // static
-scoped_ptr<CookieStoreIOS> CookieStoreIOS::CreateCookieStore(
+std::unique_ptr<CookieStoreIOS> CookieStoreIOS::CreateCookieStore(
     NSHTTPCookieStorage* cookie_storage) {
   DCHECK(cookie_storage);
   // TODO(huey): Update this when CrNet supports multiple cookie jars.
   [cookie_storage setCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways];
 
   // Create a cookie store with no persistent store backing. Then, populate
   // it from the system's cookie jar.
-  scoped_ptr<CookieStoreIOS> cookie_store(
+  std::unique_ptr<CookieStoreIOS> cookie_store(
       new CookieStoreIOS(nullptr, cookie_storage));
   cookie_store->synchronization_state_ = SYNCHRONIZED;
   cookie_store->FlushStore(base::Closure());
   return cookie_store;
 }
 
 // static
 void CookieStoreIOS::SwitchSynchronizedStore(CookieStoreIOS* old_store,
                                              CookieStoreIOS* new_store) {
   DCHECK(new_store);
@@ skipping 126 matching lines @@
       // should be written there instead.
       DCHECK(SystemCookiesAllowed());
 
       bool success = false;
 
       if (creation_time.is_null())
         creation_time = base::Time::Now();
 
       // First create a CanonicalCookie, to normalize the arguments,
       // particularly domain and path, and perform validation.
-      scoped_ptr<net::CanonicalCookie> canonical_cookie =
+      std::unique_ptr<net::CanonicalCookie> canonical_cookie =
           net::CanonicalCookie::Create(
               url, name, value, domain, path, creation_time, expiration_time,
-              secure, http_only, same_site, enforce_strict_secure,
-              priority);
+              secure, http_only, same_site, enforce_strict_secure, priority);
 
       if (canonical_cookie) {
         NSHTTPCookie* cookie =
             SystemCookieFromCanonicalCookie(*canonical_cookie);
 
         if (cookie != nil) {
           [system_store_ setCookie:cookie];
           creation_time_manager_->SetCreationTime(
               cookie, creation_time_manager_->MakeUniqueCreationTime(
                           canonical_cookie->CreationDate()));
@@ skipping 474 matching lines @@
   // Do not schedule a flush if one is already scheduled.
   if (!flush_closure_.IsCancelled())
     return;
 
   flush_closure_.Reset(base::Bind(&CookieStoreIOS::FlushStore,
                                   weak_factory_.GetWeakPtr(), base::Closure()));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, flush_closure_.callback(), flush_delay_);
 }
 
-scoped_ptr<net::CookieStore::CookieChangedSubscription>
+std::unique_ptr<net::CookieStore::CookieChangedSubscription>
 CookieStoreIOS::AddCallbackForCookie(const GURL& gurl,
                                      const std::string& name,
                                      const CookieChangedCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Prefill cookie cache with all pertinent cookies for |url| if needed.
   std::pair<GURL, std::string> key(gurl, name);
   if (hook_map_.count(key) == 0) {
     UpdateCacheForCookieFromSystem(gurl, name, nullptr, nullptr);
     if (hook_map_.count(key) == 0)
@@ skipping 158 matching lines @@
                     weak_factory_.GetWeakPtr(), callback);
 }
 
 base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure,
                     weak_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace net