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

ios/net/cookies/cookie_store_ios_unittest.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 <memory>
+
 #include "base/bind_helpers.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/cookies/cookie_store_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 // Clears the underlying NSHTTPCookieStorage.
 void ClearCookies() {
   NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
   [store setCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways];
   NSArray* cookies = [store cookies];
   for (NSHTTPCookie* cookie in cookies)
     [store deleteCookie:cookie];
   EXPECT_EQ(0u, [[store cookies] count]);
 }
 }  // namespace
 
 namespace net {
 
 struct CookieStoreIOSTestTraits {
-  static scoped_ptr<net::CookieStore> Create() {
+  static std::unique_ptr<net::CookieStore> Create() {
     ClearCookies();
-    scoped_ptr<CookieStoreIOS> store(new CookieStoreIOS(nullptr));
+    std::unique_ptr<CookieStoreIOS> store(new CookieStoreIOS(nullptr));
     store->synchronization_state_ = CookieStoreIOS::SYNCHRONIZED;
     return std::move(store);
   }
 
   static const bool supports_http_only = false;
   static const bool supports_non_dotted_domains = false;
   static const bool preserves_trailing_dots = false;
   static const bool filters_schemes = false;
   static const bool has_path_prefix_bug = true;
   static const int creation_time_granularity_in_ms = 1000;
   static const bool enforce_strict_secure = false;
 
   base::MessageLoop loop_;
 };
 
 struct InactiveCookieStoreIOSTestTraits {
-  static scoped_ptr<net::CookieStore> Create() {
-    return make_scoped_ptr(new CookieStoreIOS(nullptr));
+  static std::unique_ptr<net::CookieStore> Create() {
+    return base::WrapUnique(new CookieStoreIOS(nullptr));
   }
 
   static const bool is_cookie_monster = false;
   static const bool supports_http_only = false;
   static const bool supports_non_dotted_domains = true;
   static const bool preserves_trailing_dots = true;
   static const bool filters_schemes = false;
   static const bool has_path_prefix_bug = false;
   static const int creation_time_granularity_in_ms = 0;
   static const int enforces_prefixes = true;
@@ skipping 101 matching lines @@
   void DeleteSessionCookiesAsync(const DeleteCallback& callback) override {
     RoundTrip();
     store_->DeleteSessionCookiesAsync(callback);
   }
 
   void FlushStore(const base::Closure& callback) override {
     RoundTrip();
     store_->FlushStore(callback);
   }
 
-  scoped_ptr<CookieStore::CookieChangedSubscription> AddCallbackForCookie(
+  std::unique_ptr<CookieStore::CookieChangedSubscription> AddCallbackForCookie(
       const GURL& url,
       const std::string& name,
       const CookieChangedCallback& callback) override {
-    return scoped_ptr<CookieStore::CookieChangedSubscription>();
+    return std::unique_ptr<CookieStore::CookieChangedSubscription>();
   }
 
   bool IsEphemeral() override {
     return store_->IsEphemeral();
   }
 
  private:
   void RoundTrip() {
     CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store_.get());
     // Check that the system store is empty, because it is synchronized with
     // |dummy_store_| which is empty.
     NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
     EXPECT_EQ(0u, [[store cookies] count]);
     CookieStoreIOS::SwitchSynchronizedStore(dummy_store_.get(), store_.get());
   }
 
-  scoped_ptr<CookieStoreIOS> store_;
+  std::unique_ptr<CookieStoreIOS> store_;
   // |dummy_store_| is not directly used, but is needed to make |store_|
   // inactive.
-  scoped_ptr<CookieStoreIOS> dummy_store_;
+  std::unique_ptr<CookieStoreIOS> dummy_store_;
 };
 
 struct RoundTripTestCookieStoreTraits {
-  static scoped_ptr<net::CookieStore> Create() {
+  static std::unique_ptr<net::CookieStore> Create() {
     ClearCookies();
-    return make_scoped_ptr(new RoundTripTestCookieStore());
+    return base::WrapUnique(new RoundTripTestCookieStore());
   }
 
   static const bool is_cookie_monster = false;
   static const bool supports_http_only = false;
   static const bool supports_non_dotted_domains = false;
   static const bool preserves_trailing_dots = false;
   static const bool filters_schemes = false;
   static const bool has_path_prefix_bug = true;
   static const int creation_time_granularity_in_ms = 1000;
   static const int enforces_prefixes = true;
@@ skipping 27 matching lines @@
  public:
   TestPersistentCookieStore()
       : kTestCookieURL("http://foo.google.com/bar"), flushed_(false) {}
 
   // Runs the completion callback with a "a=b" cookie.
   void RunLoadedCallback() {
     std::vector<net::CanonicalCookie*> cookies;
     net::CookieOptions options;
     options.set_include_httponly();
 
-    scoped_ptr<net::CanonicalCookie> cookie(net::CanonicalCookie::Create(
+    std::unique_ptr<net::CanonicalCookie> cookie(net::CanonicalCookie::Create(
         kTestCookieURL, "a=b", base::Time::Now(), options));
     cookies.push_back(cookie.release());
 
     // Some canonical cookies cannot be converted into System cookies, for
     // example if value is not valid utf8. Such cookies are ignored.
     net::CanonicalCookie* bad_canonical_cookie = new net::CanonicalCookie(
         kTestCookieURL, "name", "\x81r\xe4\xbd\xa0\xe5\xa5\xbd", "domain",
         "path/",
         base::Time(),  // creation
         base::Time(),  // expires
@@ skipping 162 matching lines @@
   }
 
  protected:
   const GURL kTestCookieURL;
   const GURL kTestCookieURL2;
   const GURL kTestCookieURL3;
   const GURL kTestCookieURL4;
 
   base::MessageLoop loop_;
   scoped_refptr<TestPersistentCookieStore> backend_;
-  scoped_ptr<net::CookieStoreIOS> store_;
-  scoped_ptr<net::CookieStore::CookieChangedSubscription>
+  std::unique_ptr<net::CookieStoreIOS> store_;
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription>
       cookie_changed_callback_;
   std::vector<net::CanonicalCookie> cookies_changed_;
   std::vector<bool> cookies_removed_;
 };
 
 }  // namespace
 
 namespace net {
 
 TEST_F(CookieStoreIOSWithBackend, SetCookieCallsHookWhenNotSynchronized) {
@@ skipping 78 matching lines @@
   EXPECT_EQ(1U, cookies_changed_.size());
   SetCookie("abc=def");
   EXPECT_EQ(1U, cookies_changed_.size());
   store_->UnSynchronize();
 }
 
 TEST(CookieStoreIOS, GetAllCookiesForURLAsync) {
   base::MessageLoop loop;
   const GURL kTestCookieURL("http://foo.google.com/bar");
   ClearCookies();
-  scoped_ptr<CookieStoreIOS> cookie_store(new CookieStoreIOS(nullptr));
+  std::unique_ptr<CookieStoreIOS> cookie_store(new CookieStoreIOS(nullptr));
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, cookie_store.get());
   // Add a cookie.
   net::CookieOptions options;
   options.set_include_httponly();
   cookie_store->SetCookieWithOptionsAsync(
       kTestCookieURL, "a=b", options, net::CookieStore::SetCookiesCallback());
   // Disallow cookies.
   CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::BLOCK);
   // No cookie in the system store.
   NSHTTPCookieStorage* system_store =
@@ skipping 57 matching lines @@
   backend_->RunLoadedCallback();
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
   store_->UnSynchronize();
 }
 
 // Tests that Synchronization can be "aborted" (i.e. the cookie store is
 // unsynchronized while synchronization is in progress).
 TEST_F(CookieStoreIOSWithBackend, SyncThenUnsync) {
   ClearCookies();
-  scoped_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
+  std::unique_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
   // Switch back and forth before synchronization can complete.
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store.get());
   backend_->RunLoadedCallback();
   // No cookie leak in the system store.
   NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
   EXPECT_EQ(0u, [[store cookies] count]);
   // No cookie lost.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
   dummy_store->UnSynchronize();
 }
 
 // Tests that Synchronization can be "aborted" while there are pending tasks
 // (i.e. the cookie store is unsynchronized while synchronization is in progress
 // and there are pending tasks).
 TEST_F(CookieStoreIOSWithBackend, SyncThenUnsyncWithPendingTasks) {
   ClearCookies();
-  scoped_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
+  std::unique_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
   // Start synchornization.
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   // Create a pending task while synchronization is in progress.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   // Cancel the synchronization.
   CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store.get());
   // Synchronization completes after being cancelled.
   backend_->RunLoadedCallback();
   // The task is not lost.
@@ skipping 77 matching lines @@
 }
 
 TEST_F(CookieStoreIOSWithBackend, FlushOnUnSynchronize) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   EXPECT_FALSE(backend_->flushed());
   store_->UnSynchronize();
   EXPECT_TRUE(backend_->flushed());
 }
 
 TEST_F(CookieStoreIOSWithBackend, FlushOnSwitch) {
-  scoped_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
+  std::unique_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   EXPECT_FALSE(backend_->flushed());
   CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store.get());
   EXPECT_TRUE(backend_->flushed());
   dummy_store->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, FlushOnCookieChanged) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   store_->set_flush_delay_for_testing(base::TimeDelta());
@@ skipping 50 matching lines @@
   EXPECT_EQ(0U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, NotifyOnAdd) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<bool> removes;
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, &removes));
   EXPECT_EQ(0U, cookies.size());
   EXPECT_EQ(0U, removes.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ(1U, removes.size());
   EXPECT_EQ("abc", cookies[0].Name());
   EXPECT_EQ("def", cookies[0].Value());
   EXPECT_FALSE(removes[0]);
 
   SetSystemCookie(kTestCookieURL, "ghi", "jkl");
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ(1U, removes.size());
 
   DeleteSystemCookie(kTestCookieURL, "abc");
   DeleteSystemCookie(kTestCookieURL, "ghi");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, NotifyOnChange) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<bool> removes;
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, &removes));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "ghi");
   EXPECT_EQ(3U, cookies.size());
   EXPECT_EQ(3U, removes.size());
   EXPECT_EQ("abc", cookies[1].Name());
   EXPECT_EQ("def", cookies[1].Value());
   EXPECT_TRUE(removes[1]);
   EXPECT_EQ("abc", cookies[2].Name());
   EXPECT_EQ("ghi", cookies[2].Value());
   EXPECT_FALSE(removes[2]);
 
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, NotifyOnDelete) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<bool> removes;
   SetSystemCookie(kTestCookieURL, "abc", "def");
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, &removes));
   EXPECT_EQ(0U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ(1U, removes.size());
   EXPECT_TRUE(removes[0]);
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(2U, cookies.size());
   EXPECT_EQ(2U, removes.size());
   EXPECT_FALSE(removes[1]);
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, NoNotifyOnNoChange) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, MultipleNotifies) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<net::CanonicalCookie> cookies2;
   std::vector<net::CanonicalCookie> cookies3;
   std::vector<net::CanonicalCookie> cookies4;
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle2 =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle2 =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies2, nullptr));
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle3 =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle3 =
       store_->AddCallbackForCookie(
           kTestCookieURL3, "abc",
           base::Bind(&RecordCookieChanges, &cookies3, nullptr));
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle4 =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle4 =
       store_->AddCallbackForCookie(
           kTestCookieURL4, "abc",
           base::Bind(&RecordCookieChanges, &cookies4, nullptr));
   SetSystemCookie(kTestCookieURL, "abc", "def");
   SetSystemCookie(kTestCookieURL2, "abc", "def");
   SetSystemCookie(kTestCookieURL3, "abc", "def");
   SetSystemCookie(kTestCookieURL4, "abc", "def");
   EXPECT_EQ(2U, cookies.size());
   EXPECT_EQ(2U, cookies2.size());
   EXPECT_EQ(1U, cookies3.size());
   EXPECT_EQ(1U, cookies4.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   DeleteSystemCookie(kTestCookieURL2, "abc");
   DeleteSystemCookie(kTestCookieURL3, "abc");
   DeleteSystemCookie(kTestCookieURL4, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, LessSpecificNestedCookie) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL2, "abc", "def");
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL3, "abc", "ghi");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, MoreSpecificNestedCookie) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL3, "abc", "def");
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL2, "abc", "ghi");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, MoreSpecificNestedCookieWithSameValue) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL3, "abc", "def");
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL2, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 TEST_F(CookieStoreIOSWithBackend, RemoveCallback) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL, "abc", "def");
-  scoped_ptr<net::CookieStore::CookieChangedSubscription> handle =
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "ghi");
   EXPECT_EQ(2U, cookies.size());
   // this deletes the callback
   handle.reset();
   SetSystemCookie(kTestCookieURL, "abc", "jkl");
   EXPECT_EQ(2U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 }  // namespace net