Implements strict secure cookies as the default behavior in //net

net/cookies/cookie_store_unittest.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_COOKIE_STORE_UNITTEST_H_
 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 47 matching lines @@
 //   // The cookie store rejects cookies for invalid schemes such as ftp.
 //   static const bool filters_schemes;
 //
 //   // The cookie store has a bug happening when a path is a substring of
 //   // another.
 //   static const bool has_path_prefix_bug;
 //
 //   // Time to wait between two cookie insertions to ensure that cookies have
 //   // different creation times.
 //   static const int creation_time_granularity_in_ms;
-//
-//   // The cookie store enforces secure flag requires a secure scheme.
-//   static const bool enforce_strict_secure;
 // };
 
 template <class CookieStoreTestTraits>
 class CookieStoreTest : public testing::Test {
  protected:
   CookieStoreTest()
       : http_www_google_("http://www.google.izzle"),
         https_www_google_("https://www.google.izzle"),
         ftp_google_("ftp://ftp.google.izzle/"),
         ws_www_google_("ws://www.google.izzle"),
@@ skipping 89 matching lines @@
                             const base::Time expiration_time,
                             const base::Time last_access_time,
                             bool secure,
                             bool http_only,
                             CookieSameSite same_site,
                             CookiePriority priority) {
     DCHECK(cs);
     ResultSavingCookieCallback<bool> callback;
     cs->SetCookieWithDetailsAsync(
         url, name, value, domain, path, creation_time, expiration_time,
-        last_access_time, secure, http_only, same_site,
-        false /* enforces strict secure cookies */, priority,
+        last_access_time, secure, http_only, same_site, priority,
         base::Bind(&ResultSavingCookieCallback<bool>::Run,
                    base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
   bool SetCookieWithServerTime(CookieStore* cs,
                                const GURL& url,
                                const std::string& cookie_line,
                                const base::Time& server_time) {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
     options.set_server_time(server_time);
     return SetCookieWithOptions(cs, url, cookie_line, options);
   }
 
   bool SetCookie(CookieStore* cs,
                  const GURL& url,
                  const std::string& cookie_line) {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
-    if (CookieStoreTestTraits::enforce_strict_secure)
-      options.set_enforce_strict_secure();
     return SetCookieWithOptions(cs, url, cookie_line, options);
   }
 
   void DeleteCookie(CookieStore* cs,
                     const GURL& url,
                     const std::string& cookie_name) {
     DCHECK(cs);
     NoResultCookieCallback callback;
     cs->DeleteCookieAsync(
         url, cookie_name,
@@ skipping 131 matching lines @@
   EXPECT_TRUE(this->SetCookieWithDetails(
       cs, this->www_google_foo_.url(), "A", "B", std::string(), "/foo",
       one_hour_ago, one_hour_from_now, base::Time(), false, false,
       CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   // Note that for the creation time to be set exactly, without modification,
   // it must be different from the one set by the line above.
   EXPECT_TRUE(this->SetCookieWithDetails(
       cs, this->www_google_bar_.url(), "C", "D", this->www_google_bar_.domain(),
       "/bar", two_hours_ago, base::Time(), one_hour_ago, false, true,
       CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
+  // Because of strict secure cookies, a cookie made by an HTTP URL should fail
+  // to create a cookie with a the secure attribute.
+  EXPECT_FALSE(this->SetCookieWithDetails(
+      cs, this->http_www_google_.url(), "E", "F", std::string(), std::string(),
+      base::Time(), base::Time(), base::Time(), true, false,
+      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(this->SetCookieWithDetails(
-      cs, this->http_www_google_.url(), "E", "F", std::string(), std::string(),
+      cs, this->https_www_google_.url(), "E", "F", std::string(), std::string(),
       base::Time(), base::Time(), base::Time(), true, false,
       CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
 
   // Test that malformed attributes fail to set the cookie.
   EXPECT_FALSE(this->SetCookieWithDetails(
       cs, this->www_google_foo_.url(), " A", "B", std::string(), "/foo",
       base::Time(), base::Time(), base::Time(), false, false,
       CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   EXPECT_FALSE(this->SetCookieWithDetails(
       cs, this->www_google_foo_.url(), "A;", "B", std::string(), "/foo",
@@ skipping 1086 matching lines @@
                            OverwritePersistentCookie,
                            CookieOrdering,
                            GetAllCookiesAsync,
                            DeleteCookieAsync,
                            DeleteCanonicalCookieAsync,
                            DeleteSessionCookie);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_UNITTEST_H_