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

net/cookies/canonical_cookie_unittest.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/canonical_cookie.h"
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
 #include "base/test/histogram_tester.h"
 #include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_options.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 TEST(CanonicalCookieTest, Constructor) {
   GURL url("http://www.example.com/test");
@@ skipping 24 matching lines @@
   EXPECT_FALSE(cookie2.IsHttpOnly());
   EXPECT_EQ(CookieSameSite::NO_RESTRICTION, cookie2.SameSite());
 }
 
 TEST(CanonicalCookieTest, Create) {
   // Test creating cookies from a cookie string.
   GURL url("http://www.example.com/test/foo.html");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
 
-  scoped_ptr<CanonicalCookie> cookie(
+  std::unique_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url, "A=2", creation_time, options));
   EXPECT_EQ(url.GetOrigin(), cookie->Source());
   EXPECT_EQ("A", cookie->Name());
   EXPECT_EQ("2", cookie->Value());
   EXPECT_EQ("www.example.com", cookie->Domain());
   EXPECT_EQ("/test", cookie->Path());
   EXPECT_FALSE(cookie->IsSecure());
 
   GURL url2("http://www.foo.com");
   cookie = CanonicalCookie::Create(url2, "B=1", creation_time, options);
@@ skipping 56 matching lines @@
   EXPECT_EQ(".www.example.com", cookie->Domain());
   EXPECT_EQ("/test", cookie->Path());
   EXPECT_FALSE(cookie->IsSecure());
   EXPECT_FALSE(cookie->IsHttpOnly());
   EXPECT_EQ(CookieSameSite::NO_RESTRICTION, cookie->SameSite());
 }
 
 TEST(CanonicalCookieTest, CreateInvalidSameSite) {
   GURL url("http://www.example.com/test/foo.html");
   base::Time now = base::Time::Now();
-  scoped_ptr<CanonicalCookie> cookie;
+  std::unique_ptr<CanonicalCookie> cookie;
   CookieOptions options;
 
   // Invalid 'SameSite' attribute values.
   options.set_same_site_cookie_mode(
       CookieOptions::SameSiteCookieMode::INCLUDE_STRICT_AND_LAX);
 
   cookie = CanonicalCookie::Create(url, "A=2; SameSite=Invalid", now, options);
   EXPECT_EQ(nullptr, cookie.get());
 
   cookie = CanonicalCookie::Create(url, "A=2; SameSite", now, options);
   EXPECT_EQ(nullptr, cookie.get());
 }
 
 TEST(CanonicalCookieTest, EmptyExpiry) {
   GURL url("http://www7.ipdl.inpit.go.jp/Tokujitu/tjkta.ipdl?N0000=108");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
 
   std::string cookie_line =
       "ACSTM=20130308043820420042; path=/; domain=ipdl.inpit.go.jp; Expires=";
-  scoped_ptr<CanonicalCookie> cookie(
+  std::unique_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url, cookie_line, creation_time, options));
   EXPECT_TRUE(cookie.get());
   EXPECT_FALSE(cookie->IsPersistent());
   EXPECT_FALSE(cookie->IsExpired(creation_time));
   EXPECT_EQ(base::Time(), cookie->ExpiryDate());
 
   // With a stale server time
   options.set_server_time(creation_time - base::TimeDelta::FromHours(1));
   cookie = CanonicalCookie::Create(url, cookie_line, creation_time, options);
   EXPECT_TRUE(cookie.get());
@@ skipping 17 matching lines @@
   std::string cookie_domain = ".www.example.com";
   std::string cookie_path = "/";
   base::Time creation_time = base::Time::Now();
   base::Time last_access_time = creation_time;
   base::Time expiration_time = creation_time + base::TimeDelta::FromDays(2);
   bool secure(false);
   bool httponly(false);
   CookieSameSite same_site(CookieSameSite::NO_RESTRICTION);
 
   // Test that a cookie is equivalent to itself.
-  scoped_ptr<CanonicalCookie> cookie(new CanonicalCookie(
+  std::unique_ptr<CanonicalCookie> cookie(new CanonicalCookie(
       url, cookie_name, cookie_value, cookie_domain, cookie_path, creation_time,
       expiration_time, last_access_time, secure, httponly, same_site,
       COOKIE_PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsEquivalent(*cookie));
 
   // Test that two identical cookies are equivalent.
-  scoped_ptr<CanonicalCookie> other_cookie(new CanonicalCookie(
+  std::unique_ptr<CanonicalCookie> other_cookie(new CanonicalCookie(
       url, cookie_name, cookie_value, cookie_domain, cookie_path, creation_time,
       expiration_time, last_access_time, secure, httponly, same_site,
       COOKIE_PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsEquivalent(*other_cookie));
 
   // Tests that use different variations of attribute values that
   // DON'T affect cookie equivalence.
   other_cookie.reset(
       new CanonicalCookie(url, cookie_name, "2", cookie_domain, cookie_path,
                           creation_time, expiration_time, last_access_time,
@@ skipping 62 matching lines @@
   std::string cookie_domain = ".www.example.com";
   std::string cookie_path = "/";
   base::Time creation_time = base::Time::Now();
   base::Time last_access_time = creation_time;
   base::Time expiration_time = creation_time + base::TimeDelta::FromDays(2);
   bool secure(false);
   bool httponly(false);
   CookieSameSite same_site(CookieSameSite::NO_RESTRICTION);
 
   // Test that a cookie is equivalent to itself.
-  scoped_ptr<CanonicalCookie> cookie(new CanonicalCookie(
+  std::unique_ptr<CanonicalCookie> cookie(new CanonicalCookie(
       url, cookie_name, cookie_value, cookie_domain, cookie_path, creation_time,
       expiration_time, last_access_time, secure, httponly, same_site,
       COOKIE_PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsEquivalentForSecureCookieMatching(*cookie));
 
   // Test that two identical cookies are equivalent.
-  scoped_ptr<CanonicalCookie> other_cookie(new CanonicalCookie(
+  std::unique_ptr<CanonicalCookie> other_cookie(new CanonicalCookie(
       url, cookie_name, cookie_value, cookie_domain, cookie_path, creation_time,
       expiration_time, last_access_time, secure, httponly, same_site,
       COOKIE_PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsEquivalentForSecureCookieMatching(*other_cookie));
 
   // Tests that use different variations of attribute values that
   // DON'T affect cookie equivalence. Differs from the IsEquivalent tests above
   // as follows:
   //    * Should return true even if paths differ.
   //    * Should return true if the domains "domain-match" (but are not
@@ skipping 61 matching lines @@
                           creation_time, expiration_time, last_access_time,
                           secure, httponly, same_site, COOKIE_PRIORITY_MEDIUM));
   EXPECT_FALSE(cookie->IsEquivalentForSecureCookieMatching(*other_cookie));
 }
 
 TEST(CanonicalCookieTest, IsDomainMatch) {
   GURL url("http://www.example.com/test/foo.html");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
 
-  scoped_ptr<CanonicalCookie> cookie(
+  std::unique_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url, "A=2", creation_time, options));
   EXPECT_TRUE(cookie->IsHostCookie());
   EXPECT_TRUE(cookie->IsDomainMatch("www.example.com"));
   EXPECT_TRUE(cookie->IsDomainMatch("www.example.com"));
   EXPECT_FALSE(cookie->IsDomainMatch("foo.www.example.com"));
   EXPECT_FALSE(cookie->IsDomainMatch("www0.example.com"));
   EXPECT_FALSE(cookie->IsDomainMatch("example.com"));
 
   cookie = CanonicalCookie::Create(url, "A=2; Domain=www.example.com",
                                    creation_time, options);
@@ skipping 10 matching lines @@
   EXPECT_TRUE(cookie->IsDomainMatch("www.example.com"));
   EXPECT_TRUE(cookie->IsDomainMatch("foo.www.example.com"));
   EXPECT_FALSE(cookie->IsDomainMatch("www0.example.com"));
   EXPECT_FALSE(cookie->IsDomainMatch("example.com"));
 }
 
 TEST(CanonicalCookieTest, IsOnPath) {
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
 
-  scoped_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(
+  std::unique_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(
       GURL("http://www.example.com"), "A=2", creation_time, options));
   EXPECT_TRUE(cookie->IsOnPath("/"));
   EXPECT_TRUE(cookie->IsOnPath("/test"));
   EXPECT_TRUE(cookie->IsOnPath("/test/bar.html"));
 
   // Test the empty string edge case.
   EXPECT_FALSE(cookie->IsOnPath(std::string()));
 
   cookie = CanonicalCookie::Create(GURL("http://www.example.com/test/foo.html"),
                                    "A=2", creation_time, options);
   EXPECT_FALSE(cookie->IsOnPath("/"));
   EXPECT_TRUE(cookie->IsOnPath("/test"));
   EXPECT_TRUE(cookie->IsOnPath("/test/bar.html"));
   EXPECT_TRUE(cookie->IsOnPath("/test/sample/bar.html"));
 }
 
 TEST(CanonicalCookieTest, IncludeForRequestURL) {
   GURL url("http://www.example.com");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
 
-  scoped_ptr<CanonicalCookie> cookie(
+  std::unique_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url, "A=2", creation_time, options));
   EXPECT_TRUE(cookie->IncludeForRequestURL(url, options));
   EXPECT_TRUE(cookie->IncludeForRequestURL(
       GURL("http://www.example.com/foo/bar"), options));
   EXPECT_TRUE(cookie->IncludeForRequestURL(
       GURL("https://www.example.com/foo/bar"), options));
   EXPECT_FALSE(
       cookie->IncludeForRequestURL(GURL("https://sub.example.com"), options));
   EXPECT_FALSE(cookie->IncludeForRequestURL(GURL("https://sub.www.example.com"),
                                             options));
@@ skipping 22 matching lines @@
   EXPECT_TRUE(cookie->IsHttpOnly());
   EXPECT_TRUE(cookie->IncludeForRequestURL(url, options));
   options.set_exclude_httponly();
   EXPECT_FALSE(cookie->IncludeForRequestURL(url, options));
 }
 
 TEST(CanonicalCookieTest, IncludeSameSiteForSameSiteURL) {
   GURL url("https://example.test");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
-  scoped_ptr<CanonicalCookie> cookie;
+  std::unique_ptr<CanonicalCookie> cookie;
 
   // `SameSite=Strict` cookies are included for a URL only if the options'
   // SameSiteCookieMode is INCLUDE_STRICT_AND_LAX.
   cookie = CanonicalCookie::Create(url, "A=2; SameSite=Strict", creation_time,
                                    options);
   EXPECT_EQ(CookieSameSite::STRICT_MODE, cookie->SameSite());
   options.set_same_site_cookie_mode(
       CookieOptions::SameSiteCookieMode::DO_NOT_INCLUDE);
   EXPECT_FALSE(cookie->IncludeForRequestURL(url, options));
   options.set_same_site_cookie_mode(
@@ skipping 16 matching lines @@
   EXPECT_TRUE(cookie->IncludeForRequestURL(url, options));
   options.set_same_site_cookie_mode(
       CookieOptions::SameSiteCookieMode::INCLUDE_STRICT_AND_LAX);
   EXPECT_TRUE(cookie->IncludeForRequestURL(url, options));
 }
 
 TEST(CanonicalCookieTest, PartialCompare) {
   GURL url("http://www.example.com");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
-  scoped_ptr<CanonicalCookie> cookie(
+  std::unique_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url, "a=b", creation_time, options));
-  scoped_ptr<CanonicalCookie> cookie_different_path(
+  std::unique_ptr<CanonicalCookie> cookie_different_path(
       CanonicalCookie::Create(url, "a=b; path=/foo", creation_time, options));
-  scoped_ptr<CanonicalCookie> cookie_different_value(
+  std::unique_ptr<CanonicalCookie> cookie_different_value(
       CanonicalCookie::Create(url, "a=c", creation_time, options));
 
   // Cookie is equivalent to itself.
   EXPECT_FALSE(cookie->PartialCompare(*cookie));
 
   // Changing the path affects the ordering.
   EXPECT_TRUE(cookie->PartialCompare(*cookie_different_path));
   EXPECT_FALSE(cookie_different_path->PartialCompare(*cookie));
 
   // Changing the value does not affect the ordering.
   EXPECT_FALSE(cookie->PartialCompare(*cookie_different_value));
   EXPECT_FALSE(cookie_different_value->PartialCompare(*cookie));
 
   // Cookies identical for PartialCompare() are equivalent.
   EXPECT_TRUE(cookie->IsEquivalent(*cookie_different_value));
   EXPECT_TRUE(cookie->IsEquivalent(*cookie));
 }
 
 TEST(CanonicalCookieTest, FullCompare) {
   GURL url("http://www.example.com");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
-  scoped_ptr<CanonicalCookie> cookie(
+  std::unique_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url, "a=b", creation_time, options));
-  scoped_ptr<CanonicalCookie> cookie_different_path(
+  std::unique_ptr<CanonicalCookie> cookie_different_path(
       CanonicalCookie::Create(url, "a=b; path=/foo", creation_time, options));
-  scoped_ptr<CanonicalCookie> cookie_different_value(
+  std::unique_ptr<CanonicalCookie> cookie_different_value(
       CanonicalCookie::Create(url, "a=c", creation_time, options));
 
   // Cookie is equivalent to itself.
   EXPECT_FALSE(cookie->FullCompare(*cookie));
 
   // Changing the path affects the ordering.
   EXPECT_TRUE(cookie->FullCompare(*cookie_different_path));
   EXPECT_FALSE(cookie_different_path->FullCompare(*cookie));
 
   // Changing the value affects the ordering.
@@ skipping 89 matching lines @@
       options));
 }
 
 TEST(CanonicalCookieTest, EnforceSecureCookiesRequireSecureScheme) {
   GURL http_url("http://www.example.com");
   GURL https_url("https://www.example.com");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
   options.set_enforce_strict_secure();
 
-  scoped_ptr<CanonicalCookie> http_cookie_no_secure(
+  std::unique_ptr<CanonicalCookie> http_cookie_no_secure(
       CanonicalCookie::Create(http_url, "a=b", creation_time, options));
-  scoped_ptr<CanonicalCookie> http_cookie_secure(
+  std::unique_ptr<CanonicalCookie> http_cookie_secure(
       CanonicalCookie::Create(http_url, "a=b; Secure", creation_time, options));
-  scoped_ptr<CanonicalCookie> https_cookie_no_secure(
+  std::unique_ptr<CanonicalCookie> https_cookie_no_secure(
       CanonicalCookie::Create(https_url, "a=b", creation_time, options));
-  scoped_ptr<CanonicalCookie> https_cookie_secure(CanonicalCookie::Create(
+  std::unique_ptr<CanonicalCookie> https_cookie_secure(CanonicalCookie::Create(
       https_url, "a=b; Secure", creation_time, options));
 
   EXPECT_TRUE(http_cookie_no_secure.get());
   EXPECT_FALSE(http_cookie_secure.get());
   EXPECT_TRUE(https_cookie_no_secure.get());
   EXPECT_TRUE(https_cookie_secure.get());
 
-  scoped_ptr<CanonicalCookie> http_cookie_no_secure_extended(
+  std::unique_ptr<CanonicalCookie> http_cookie_no_secure_extended(
       CanonicalCookie::Create(
           http_url, "a", "b", "", "", creation_time, creation_time, false,
           false, CookieSameSite::STRICT_MODE, true, COOKIE_PRIORITY_DEFAULT));
-  scoped_ptr<CanonicalCookie> http_cookie_secure_extended(
+  std::unique_ptr<CanonicalCookie> http_cookie_secure_extended(
       CanonicalCookie::Create(
           http_url, "a", "b", "", "", creation_time, creation_time, true, false,
           CookieSameSite::STRICT_MODE, true, COOKIE_PRIORITY_DEFAULT));
-  scoped_ptr<CanonicalCookie> https_cookie_no_secure_extended(
+  std::unique_ptr<CanonicalCookie> https_cookie_no_secure_extended(
       CanonicalCookie::Create(
           https_url, "a", "b", "", "", creation_time, creation_time, false,
           false, CookieSameSite::STRICT_MODE, true, COOKIE_PRIORITY_DEFAULT));
-  scoped_ptr<CanonicalCookie> https_cookie_secure_extended(
+  std::unique_ptr<CanonicalCookie> https_cookie_secure_extended(
       CanonicalCookie::Create(
           https_url, "a", "b", "", "", creation_time, creation_time, true,
           false, CookieSameSite::STRICT_MODE, true, COOKIE_PRIORITY_DEFAULT));
 
   EXPECT_TRUE(http_cookie_no_secure_extended.get());
   EXPECT_FALSE(http_cookie_secure_extended.get());
   EXPECT_TRUE(https_cookie_no_secure_extended.get());
   EXPECT_TRUE(https_cookie_secure_extended.get());
 }
 
@@ skipping 41 matching lines @@
                                CanonicalCookie::COOKIE_PREFIX_SECURE, 1);
   EXPECT_TRUE(CanonicalCookie::Create(https_url, "__SecureA=B; Path=/; Secure",
                                       creation_time, options));
   histograms.ExpectBucketCount(kCookiePrefixHistogram,
                                CanonicalCookie::COOKIE_PREFIX_SECURE, 2);
   histograms.ExpectBucketCount(kCookiePrefixBlockedHistogram,
                                CanonicalCookie::COOKIE_PREFIX_SECURE, 1);
 }
 
 }  // namespace net