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

ios/net/cookies/cookie_store_ios.mm

 // Copyright 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 "ios/net/cookies/cookie_store_ios.h"
 
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 
 #include "base/bind.h"
@@ skipping 370 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) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->SetCookieWithDetailsAsync(
           url, name, value, domain, path, creation_time, expiration_time,
-          last_access_time, secure, http_only, same_site, enforce_strict_secure,
-          priority, WrapSetCallback(callback));
+          last_access_time, secure, http_only, same_site, priority,
+          WrapSetCallback(callback));
       break;
     case SYNCHRONIZED:
       // If cookies are not allowed, they are stashed in the CookieMonster, and
       // should be written there instead.
       DCHECK(SystemCookiesAllowed());
 
       bool success = false;
 
       if (creation_time.is_null())
         creation_time = base::Time::Now();
 
       // First create a CanonicalCookie, to normalize the arguments,
       // particularly domain and path, and perform validation.
       std::unique_ptr<net::CanonicalCookie> canonical_cookie =
           net::CanonicalCookie::Create(
               url, name, value, domain, path, creation_time, expiration_time,
-              secure, http_only, same_site, enforce_strict_secure, priority);
+              secure, http_only, same_site, priority);
 
       if (canonical_cookie) {
         NSHTTPCookie* cookie =
             SystemCookieFromCanonicalCookie(*canonical_cookie);
 
         if (cookie != nil) {
           [system_store_ setCookie:cookie];
           creation_time_manager_->SetCreationTime(
               cookie, creation_time_manager_->MakeUniqueCreationTime(
                           canonical_cookie->CreationDate()));
@@ skipping 500 matching lines @@
                     weak_factory_.GetWeakPtr(), callback);
 }
 
 base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure,
                     weak_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace net