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

ios/net/cookies/cookie_store_ios.h

 // 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.
 
 #ifndef IOS_NET_COOKIES_COOKIE_STORE_IOS_H_
 #define IOS_NET_COOKIES_COOKIE_STORE_IOS_H_
 
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "ios/net/cookies/cookie_cache.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "url/gurl.h"
 
 @class NSHTTPCookie;
 @class NSHTTPCookieStorage;
@@ skipping 53 matching lines @@
   // Must be called on the thread where CookieStoreIOS instances live.
   // Affects only those CookieStoreIOS instances that are backed by
   // |NSHTTPCookieStorage sharedHTTPCookieStorage|.
   static void SetCookiePolicy(CookiePolicy setting);
 
   // Create an instance of CookieStoreIOS that is generated from the cookies
   // stored in |cookie_storage|. The CookieStoreIOS uses the |cookie_storage|
   // as its default backend and is initially synchronized with it.
   // Apple does not persist the cookies' creation dates in NSHTTPCookieStorage,
   // so callers should not expect these values to be populated.
-  static scoped_ptr<CookieStoreIOS> CreateCookieStore(
+  static std::unique_ptr<CookieStoreIOS> CreateCookieStore(
       NSHTTPCookieStorage* cookie_storage);
 
   // As there is only one system store, only one CookieStoreIOS at a time may
   // be synchronized with it.
   static void SwitchSynchronizedStore(CookieStoreIOS* old_store,
                                       CookieStoreIOS* new_store);
 
   // Must be called when the state of
   // |NSHTTPCookieStorage sharedHTTPCookieStorage| changes.
   // Affects only those CookieStoreIOS instances that are backed by
@@ skipping 48 matching lines @@
                                     const base::Time& delete_end,
                                     const DeleteCallback& callback) override;
   void DeleteAllCreatedBetweenForHostAsync(
       const base::Time delete_begin,
       const base::Time delete_end,
       const GURL& url,
       const DeleteCallback& callback) override;
   void DeleteSessionCookiesAsync(const DeleteCallback& callback) override;
   void FlushStore(const base::Closure& callback) override;
 
-  scoped_ptr<CookieChangedSubscription> AddCallbackForCookie(
+  std::unique_ptr<CookieChangedSubscription> AddCallbackForCookie(
       const GURL& url,
       const std::string& name,
       const CookieChangedCallback& callback) override;
 
   bool IsEphemeral() override;
 
  private:
   // For tests.
   friend struct CookieStoreIOSTestTraits;
 
@@ skipping 26 matching lines @@
   // Runs all the pending tasks.
   void RunAllPendingTasks();
 
   // Inherited CookieNotificationObserver methods.
   void OnSystemCookiesChanged() override;
   void OnSystemCookiePolicyChanged() override;
 
   void DeleteCookiesWithFilter(const CookieFilterFunction& filter,
                                const DeleteCallback& callback);
 
-  scoped_ptr<net::CookieMonster> cookie_monster_;
+  std::unique_ptr<net::CookieMonster> cookie_monster_;
   base::scoped_nsobject<NSHTTPCookieStorage> system_store_;
-  scoped_ptr<CookieCreationTimeManager> creation_time_manager_;
+  std::unique_ptr<CookieCreationTimeManager> creation_time_manager_;
   bool metrics_enabled_;
   base::TimeDelta flush_delay_;
   base::CancelableClosure flush_closure_;
 
   SynchronizationState synchronization_state_;
   // Tasks received when SYNCHRONIZING are queued and run when SYNCHRONIZED.
   std::vector<base::Closure> tasks_pending_synchronization_;
 
   base::ThreadChecker thread_checker_;
 
@@ skipping 94 matching lines @@
   // callback that invokes UpdateCachesFromCookieMonster() to schedule an
   // asynchronous synchronization of the cookie cache and then calls the
   // original callback.
 
   SetCookiesCallback WrapSetCallback(const SetCookiesCallback& callback);
   DeleteCallback WrapDeleteCallback(const DeleteCallback& callback);
   base::Closure WrapClosure(const base::Closure& callback);
 
   // Cached values of system cookies. Only cookies which have an observer added
   // with AddCallbackForCookie are kept in this cache.
-  scoped_ptr<CookieCache> cookie_cache_;
+  std::unique_ptr<CookieCache> cookie_cache_;
 
   // Callbacks for cookie changes installed by AddCallbackForCookie.
   typedef std::map<std::pair<GURL, std::string>, CookieChangedCallbackList*>
       CookieChangedHookMap;
   CookieChangedHookMap hook_map_;
 
   base::WeakPtrFactory<CookieStoreIOS> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieStoreIOS);
 };
 
 }  // namespace net
 
 #endif  // IOS_NET_COOKIES_COOKIE_STORE_IOS_H_