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

net/cookies/cookie_monster.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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_COOKIES_COOKIE_MONSTER_H_
 #define NET_COOKIES_COOKIE_MONSTER_H_
 
 #include <stddef.h>
@@ skipping 146 matching lines @@
                                  const std::string& name,
                                  const std::string& value,
                                  const std::string& domain,
                                  const std::string& path,
                                  base::Time creation_time,
                                  base::Time expiration_time,
                                  base::Time last_access_time,
                                  bool secure,
                                  bool http_only,
                                  CookieSameSite same_site,
-                                 bool enforce_strict_secure,
                                  CookiePriority priority,
                                  const SetCookiesCallback& callback) override;
   void GetCookiesWithOptionsAsync(const GURL& url,
                                   const CookieOptions& options,
                                   const GetCookiesCallback& callback) override;
   void GetCookieListWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
       const GetCookieListCallback& callback) override;
   void GetAllCookiesAsync(const GetCookieListCallback& callback) override;
@@ skipping 80 matching lines @@
   // For FindCookiesForKey.
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, ShortLivedSessionCookies);
 
   // For ComputeCookieDiff.
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, ComputeCookieDiff);
 
   // For CookieSource histogram enum.
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, CookieSourceHistogram);
 
   // For kSafeFromGlobalPurgeDays in CookieStore.
-  FRIEND_TEST_ALL_PREFIXES(CookieMonsterStrictSecureTest, EvictSecureCookies);
+  FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, EvictSecureCookies);
 
   // For CookieDeleteEquivalent histogram enum.
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest,
                            CookieDeleteEquivalentHistogramTest);
-  FRIEND_TEST_ALL_PREFIXES(CookieMonsterStrictSecureTest,
-                           CookieDeleteEquivalentHistogramTest);
 
   // Internal reasons for deletion, used to populate informative histograms
   // and to provide a public cause for onCookieChange notifications.
   //
   // If you add or remove causes from this list, please be sure to also update
   // the CookieStore::ChangeCause mapping inside ChangeCauseMapping.
   // Moreover, these are used as array indexes, so avoid reordering to keep the
   // histogram buckets consistent. New items (if necessary) should be added
   // at the end of the list, just before DELETE_COOKIE_LAST_ENTRY.
   enum DeletionCause {
@@ skipping 106 matching lines @@
                             const std::string& name,
                             const std::string& value,
                             const std::string& domain,
                             const std::string& path,
                             base::Time creation_time,
                             base::Time expiration_time,
                             base::Time last_access_time,
                             bool secure,
                             bool http_only,
                             CookieSameSite same_site,
-                            bool enforce_strict_secure,
                             CookiePriority priority);
 
   CookieList GetAllCookies();
 
   CookieList GetCookieListWithOptions(const GURL& url,
                                       const CookieOptions& options);
 
   int DeleteAllCreatedBetween(const base::Time& delete_begin,
                               const base::Time& delete_end);
 
@@ skipping 75 matching lines @@
   void FindCookiesForKey(const std::string& key,
                          const GURL& url,
                          const CookieOptions& options,
                          const base::Time& current,
                          std::vector<CanonicalCookie*>* cookies);
 
   // Delete any cookies that are equivalent to |ecc| (same path, domain, etc).
   // |source_url| is the URL that is attempting to set the cookie.
   // If |skip_httponly| is true, httponly cookies will not be deleted.  The
   // return value will be true if |skip_httponly| skipped an httponly cookie or
-  // |enforce_strict_secure| is true and the cookie to
-  // delete was Secure and the scheme of |ecc| is insecure.  |key| is the key to
-  // find the cookie in cookies_; see the comment before the CookieMap typedef
-  // for details.
+  // the cookie to delete was Secure and the scheme of |ecc| is insecure.  |key|
+  // is the key to find the cookie in cookies_; see the comment before the
+  // CookieMap typedef for details.
   // NOTE: There should never be more than a single matching equivalent cookie.
   bool DeleteAnyEquivalentCookie(const std::string& key,
                                  const CanonicalCookie& ecc,
                                  const GURL& source_url,
                                  bool skip_httponly,
-                                 bool already_expired,
-                                 bool enforce_strict_secure);
+                                 bool already_expired);
 
   // Inserts |cc| into cookies_. Returns an iterator that points to the inserted
   // cookie in cookies_. Guarantee: all iterators to cookies_ remain valid.
   CookieMap::iterator InternalInsertCookie(const std::string& key,
                                            std::unique_ptr<CanonicalCookie> cc,
                                            const GURL& source_url,
                                            bool sync_to_store);
 
   // Helper function that sets cookies with more control.
   // Not exposed as we don't want callers to have the ability
@@ skipping 23 matching lines @@
   void InternalDeleteCookie(CookieMap::iterator it,
                             bool sync_to_store,
                             DeletionCause deletion_cause);
 
   // If the number of cookies for CookieMap key |key|, or globally, are
   // over the preset maximums above, garbage collect, first for the host and
   // then globally.  See comments above garbage collection threshold
   // constants for details.
   //
   // Returns the number of cookies deleted (useful for debugging).
-  size_t GarbageCollect(const base::Time& current,
-                        const std::string& key,
-                        bool enforce_strict_secure);
+  size_t GarbageCollect(const base::Time& current, const std::string& key);
 
   // Helper for GarbageCollect(). Deletes up to |purge_goal| cookies with a
   // priority less than or equal to |priority| from |cookies|, while ensuring
   // that at least the |to_protect| most-recent cookies are retained.
   // |protected_secure_cookies| specifies whether or not secure cookies should
   // be protected from deletion.
   //
   // |cookies| must be sorted from least-recent to most-recent.
   //
   // Returns the number of cookies deleted.
@@ skipping 232 matching lines @@
   virtual ~PersistentCookieStore() {}
 
  private:
   friend class base::RefCountedThreadSafe<PersistentCookieStore>;
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_H_