Convert some raw CanonicalCookie ptrs to scoped_ptr<CanonicalCookie>.

net/cookies/canonical_cookie.h

 // 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.
 
 #ifndef NET_COOKIES_CANONICAL_COOKIE_H_
 #define NET_COOKIES_CANONICAL_COOKIE_H_
 
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_options.h"
 
 class GURL;
 
 namespace net {
 
 class ParsedCookie;
@@ skipping 23 matching lines @@
   // in which pre-validation of the ParsedCookie has not been done.
   CanonicalCookie(const GURL& url, const ParsedCookie& pc);
 
   ~CanonicalCookie();
 
   // Supports the default copy constructor.
 
   // Creates a new |CanonicalCookie| from the |cookie_line| and the
   // |creation_time|. Canonicalizes and validates inputs. May return NULL if
   // an attribute value is invalid.
-  static CanonicalCookie* Create(const GURL& url,
-                                 const std::string& cookie_line,
-                                 const base::Time& creation_time,
-                                 const CookieOptions& options);
+  static scoped_ptr<CanonicalCookie> Create(const GURL& url,
+                                            const std::string& cookie_line,
+                                            const base::Time& creation_time,
+                                            const CookieOptions& options);
 
   // Creates a canonical cookie from unparsed attribute values.
   // Canonicalizes and validates inputs.  May return NULL if an attribute
   // value is invalid.
-  static 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,
-                                 bool first_party_only,
-                                 bool enforce_strict_secure,
-                                 CookiePriority priority);
+  static scoped_ptr<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,
+                                            bool first_party_only,
+                                            bool enforce_strict_secure,
+                                            CookiePriority priority);
 
   const GURL& Source() const { return source_; }
   const std::string& Name() const { return name_; }
   const std::string& Value() const { return value_; }
   const std::string& Domain() const { return domain_; }
   const std::string& Path() const { return path_; }
   const base::Time& CreationDate() const { return creation_date_; }
   const base::Time& LastAccessDate() const { return last_access_date_; }
   bool IsPersistent() const { return !expiry_date_.is_null(); }
   const base::Time& ExpiryDate() const { return expiry_date_; }
@@ skipping 120 matching lines @@
   bool httponly_;
   bool first_party_only_;
   CookiePriority priority_;
 };
 
 typedef std::vector<CanonicalCookie> CookieList;
 
 }  // namespace net
 
 #endif  // NET_COOKIES_CANONICAL_COOKIE_H_