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

net/cookies/canonical_cookie.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 28 matching lines @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "net/cookies/canonical_cookie.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 126 matching lines @@
     base::Time parsed_expiry = cookie_util::ParseCookieTime(pc.Expires());
     if (!parsed_expiry.is_null())
       return parsed_expiry + (current - server_time);
   }
 
   // Invalid or no expiration, persistent cookie.
   return Time();
 }
 
 // static
-scoped_ptr<CanonicalCookie> CanonicalCookie::Create(
+std::unique_ptr<CanonicalCookie> CanonicalCookie::Create(
     const GURL& url,
     const std::string& cookie_line,
     const base::Time& creation_time,
     const CookieOptions& options) {
   ParsedCookie parsed_cookie(cookie_line);
 
   if (!parsed_cookie.IsValid()) {
     VLOG(kVlogSetCookies) << "WARNING: Couldn't parse cookie";
     return nullptr;
   }
@@ skipping 32 matching lines @@
   CookiePrefix prefix = CanonicalCookie::GetCookiePrefix(parsed_cookie.Name());
   bool is_cookie_valid =
       CanonicalCookie::IsCookiePrefixValid(prefix, url, parsed_cookie);
   CanonicalCookie::RecordCookiePrefixMetrics(prefix, is_cookie_valid);
   if (!is_cookie_valid) {
     VLOG(kVlogSetCookies)
         << "Create() failed because the cookie violated prefix rules.";
     return nullptr;
   }
 
-  return make_scoped_ptr(new CanonicalCookie(
+  return base::WrapUnique(new CanonicalCookie(
       url, parsed_cookie.Name(), parsed_cookie.Value(), cookie_domain,
       cookie_path, creation_time, cookie_expires, creation_time,
       parsed_cookie.IsSecure(), parsed_cookie.IsHttpOnly(),
       parsed_cookie.SameSite(), parsed_cookie.Priority()));
 }
 
 // static
-scoped_ptr<CanonicalCookie> CanonicalCookie::Create(
+std::unique_ptr<CanonicalCookie> CanonicalCookie::Create(
     const GURL& url,
     const std::string& name,
     const std::string& value,
     const std::string& domain,
     const std::string& path,
     const base::Time& creation,
     const base::Time& expiration,
     bool secure,
     bool http_only,
     CookieSameSite same_site,
@@ skipping 30 matching lines @@
     return nullptr;
   // Canonicalize path again to make sure it escapes characters as needed.
   url::Component path_component(0, cookie_path.length());
   url::RawCanonOutputT<char> canon_path;
   url::Component canon_path_component;
   url::CanonicalizePath(cookie_path.data(), path_component, &canon_path,
                         &canon_path_component);
   cookie_path = std::string(canon_path.data() + canon_path_component.begin,
                             canon_path_component.len);
 
-  return make_scoped_ptr(new CanonicalCookie(
+  return base::WrapUnique(new CanonicalCookie(
       url, parsed_name, parsed_value, cookie_domain, cookie_path, creation,
       expiration, creation, secure, http_only, same_site, priority));
 }
 
 bool CanonicalCookie::IsOnPath(const std::string& url_path) const {
 
   // A zero length would be unsafe for our trailing '/' checks, and
   // would also make no sense for our prefix match.  The code that
   // creates a CanonicalCookie should make sure the path is never zero length,
   // but we double check anyway.
@@ skipping 175 matching lines @@
   if (prefix == CanonicalCookie::COOKIE_PREFIX_SECURE)
     return parsed_cookie.IsSecure() && url.SchemeIsCryptographic();
   if (prefix == CanonicalCookie::COOKIE_PREFIX_HOST) {
     return parsed_cookie.IsSecure() && url.SchemeIsCryptographic() &&
            !parsed_cookie.HasDomain() && parsed_cookie.Path() == "/";
   }
   return true;
 }
 
 }  // namespace net