Change scoped_ptr to std::unique_ptr in //net.

net/cookies/cookie_monster_store_test.cc

 // Copyright (c) 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 "net/cookies/cookie_monster_store_test.h"
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 97 matching lines @@
     const CanonicalCookie& cookie,
     bool removed,
     CookieMonsterDelegate::ChangeCause cause) {
   CookieNotification notification(cookie, removed);
   changes_.push_back(notification);
 }
 
 MockCookieMonsterDelegate::~MockCookieMonsterDelegate() {
 }
 
-scoped_ptr<CanonicalCookie> BuildCanonicalCookie(
+std::unique_ptr<CanonicalCookie> BuildCanonicalCookie(
     const GURL& url,
     const std::string& cookie_line,
     const base::Time& creation_time) {
   // Parse the cookie line.
   ParsedCookie pc(cookie_line);
   EXPECT_TRUE(pc.IsValid());
 
   // This helper is simplistic in interpreting a parsed cookie, in order to
   // avoid duplicated CookieMonster's CanonPath() and CanonExpiration()
   // functions. Would be nice to export them, and re-use here.
   EXPECT_FALSE(pc.HasMaxAge());
   EXPECT_TRUE(pc.HasPath());
   base::Time cookie_expires = pc.HasExpires()
                                   ? cookie_util::ParseCookieTime(pc.Expires())
                                   : base::Time();
   std::string cookie_path = pc.Path();
 
   return CanonicalCookie::Create(url, pc.Name(), pc.Value(), url.host(),
                                  cookie_path, creation_time, cookie_expires,
                                  pc.IsSecure(), pc.IsHttpOnly(), pc.SameSite(),
                                  false, pc.Priority());
 }
 
 void AddCookieToList(const GURL& url,
                      const std::string& cookie_line,
                      const base::Time& creation_time,
                      std::vector<CanonicalCookie*>* out_list) {
-  scoped_ptr<CanonicalCookie> cookie(
+  std::unique_ptr<CanonicalCookie> cookie(
       BuildCanonicalCookie(url, cookie_line, creation_time));
 
   out_list->push_back(cookie.release());
 }
 
 MockSimplePersistentCookieStore::MockSimplePersistentCookieStore()
     : loaded_(false) {
 }
 
 void MockSimplePersistentCookieStore::Load(
@@ skipping 47 matching lines @@
 }
 
 void MockSimplePersistentCookieStore::Flush(const base::Closure& callback) {
   if (!callback.is_null())
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
 void MockSimplePersistentCookieStore::SetForceKeepSessionState() {
 }
 
-scoped_ptr<CookieMonster> CreateMonsterFromStoreForGC(
+std::unique_ptr<CookieMonster> CreateMonsterFromStoreForGC(
     int num_secure_cookies,
     int num_old_secure_cookies,
     int num_non_secure_cookies,
     int num_old_non_secure_cookies,
     int days_old) {
   base::Time current(base::Time::Now());
   base::Time past_creation(base::Time::Now() - base::TimeDelta::FromDays(1000));
   scoped_refptr<MockSimplePersistentCookieStore> store(
       new MockSimplePersistentCookieStore);
   int total_cookies = num_secure_cookies + num_non_secure_cookies;
@@ skipping 18 matching lines @@
             ? current - base::TimeDelta::FromDays(days_old)
             : current;
 
     CanonicalCookie cc(GURL(), "a", "1", base::StringPrintf("h%05d.izzle", i),
                        "/path", creation_time, expiration_time,
                        last_access_time, secure, false,
                        CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT);
     store->AddCookie(cc);
   }
 
-  return make_scoped_ptr(new CookieMonster(store.get(), nullptr));
+  return base::WrapUnique(new CookieMonster(store.get(), nullptr));
 }
 
 MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {
 }
 
 }  // namespace net