cef/patch/patches/services_network_2622.patch

diff --git chrome/browser/net/profile_network_context_service.cc chrome/browser/net/profile_network_context_service.cc
index 2df5ce6a4ebb8..d74f93c7a4b38 100644
--- chrome/browser/net/profile_network_context_service.cc
+++ chrome/browser/net/profile_network_context_service.cc
@@ -22,6 +22,7 @@
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "build/chromeos_buildflags.h"
+#include "cef/libcef/features/runtime.h"
 #include "chrome/browser/browser_features.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
@@ -752,7 +753,19 @@ void ProfileNetworkContextService::ConfigureNetworkContextParamsInternal(
 
   // Configure on-disk storage for non-OTR profiles. OTR profiles just use
   // default behavior (in memory storage, default sizes).
-  if (!in_memory) {
+  if (!in_memory && cef::IsAlloyRuntimeEnabled()) {
+    PrefService* prefs = profile_->GetPrefs();
+    // Configure the HTTP cache path and size.
+    const base::FilePath& base_cache_path =
+        prefs->GetFilePath(prefs::kDiskCacheDir);
+    DCHECK(!base_cache_path.empty());
+    network_context_params->http_cache_directory =
+        base_cache_path.Append(chrome::kCacheDirname);
+    network_context_params->http_cache_max_size =
+        prefs->GetInteger(prefs::kDiskCacheSize);
+  }
+
+  if (!in_memory && !cef::IsAlloyRuntimeEnabled()) {
     PrefService* local_state = g_browser_process->local_state();
     // Configure the HTTP cache path and size.
     base::FilePath base_cache_path;
@@ -765,7 +778,9 @@ void ProfileNetworkContextService::ConfigureNetworkContextParamsInternal(
         base_cache_path.Append(chrome::kCacheDirname);
     network_context_params->http_cache_max_size =
         local_state->GetInteger(prefs::kDiskCacheSize);
+  }
 
+  if (!in_memory) {
     network_context_params->file_paths =
         ::network::mojom::NetworkContextFilePaths::New();
 
diff --git net/cookies/cookie_monster.cc net/cookies/cookie_monster.cc
index 644e5fc13712a..51e6c0c24ff30 100644
--- net/cookies/cookie_monster.cc
+++ net/cookies/cookie_monster.cc
@@ -540,6 +540,25 @@ void CookieMonster::SetCookieableSchemes(
   MaybeRunCookieCallback(std::move(callback), true);
 }
 
+void CookieMonster::AddCookieableSchemes(
+    const std::vector<std::string>& schemes,
+    SetCookieableSchemesCallback callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Calls to this method will have no effect if made after a WebView or
+  // CookieManager instance has been created.
+  if (initialized_) {
+    MaybeRunCookieCallback(std::move(callback), false);
+    return;
+  }
+
+  if (!schemes.empty()) {
+    cookieable_schemes_.insert(cookieable_schemes_.begin(), schemes.begin(),
+                               schemes.end());
+  }
+  MaybeRunCookieCallback(std::move(callback), true);
+}
+
 // This function must be called before the CookieMonster is used.
 void CookieMonster::SetPersistSessionCookies(bool persist_session_cookies) {
   DCHECK(thread_checker_.CalledOnValidThread());
diff --git net/cookies/cookie_monster.h net/cookies/cookie_monster.h
index d2cfebf4900dd..c908d17d881e9 100644
--- net/cookies/cookie_monster.h
+++ net/cookies/cookie_monster.h
@@ -209,6 +209,8 @@ class NET_EXPORT CookieMonster : public CookieStore {
   CookieChangeDispatcher& GetChangeDispatcher() override;
   void SetCookieableSchemes(const std::vector<std::string>& schemes,
                             SetCookieableSchemesCallback callback) override;
+  void AddCookieableSchemes(const std::vector<std::string>& schemes,
+                            SetCookieableSchemesCallback callback) override;
 
   // Enables writing session cookies into the cookie database. If this this
   // method is called, it must be called before first use of the instance
diff --git net/cookies/cookie_store.h net/cookies/cookie_store.h
index c143a7381df95..da14e2b0b1c81 100644
--- net/cookies/cookie_store.h
+++ net/cookies/cookie_store.h
@@ -163,6 +163,11 @@ class NET_EXPORT CookieStore {
   // Transfer ownership of a CookieAccessDelegate.
   void SetCookieAccessDelegate(std::unique_ptr<CookieAccessDelegate> delegate);
 
+  // Adds to the list of cookieable schemes. Does nothing if called after first
+  // use of the instance (i.e. after the instance initialization process).
+  virtual void AddCookieableSchemes(const std::vector<std::string>& schemes,
+                                    SetCookieableSchemesCallback callback) = 0;
+
   // This may be null if no delegate has been set yet, or the delegate has been
   // reset to null.
   const CookieAccessDelegate* cookie_access_delegate() const {
diff --git services/network/cookie_manager.cc services/network/cookie_manager.cc
index 77c0984d364c6..df7ff7d7355b5 100644
--- services/network/cookie_manager.cc
+++ services/network/cookie_manager.cc
@@ -387,14 +387,9 @@ void CookieManager::FlushCookieStore(FlushCookieStoreCallback callback) {
 void CookieManager::AllowFileSchemeCookies(
     bool allow,
     AllowFileSchemeCookiesCallback callback) {
-  std::vector<std::string> cookieable_schemes(
-      net::CookieMonster::kDefaultCookieableSchemes,
-      net::CookieMonster::kDefaultCookieableSchemes +
-          net::CookieMonster::kDefaultCookieableSchemesCount);
-  if (allow) {
-    cookieable_schemes.push_back(url::kFileScheme);
-  }
-  cookie_store_->SetCookieableSchemes(cookieable_schemes, std::move(callback));
+  if (!allow)
+    return;
+  cookie_store_->AddCookieableSchemes({url::kFileScheme}, std::move(callback));
 }
 
 void CookieManager::SetForceKeepSessionState() {
diff --git services/network/network_context.cc services/network/network_context.cc
index 13fc1b901b7b3..5db000001514e 100644
--- services/network/network_context.cc
+++ services/network/network_context.cc
@@ -2369,17 +2369,21 @@ URLRequestContextOwner NetworkContext::MakeURLRequestContext(
         network_service_->network_quality_estimator());
   }
 
-  if (session_cleanup_cookie_store) {
-    std::unique_ptr<net::CookieMonster> cookie_store =
-        std::make_unique<net::CookieMonster>(
-            session_cleanup_cookie_store.get(), net_log,
-            first_party_sets_access_delegate_.is_enabled());
-    if (params_->persist_session_cookies)
-      cookie_store->SetPersistSessionCookies(true);
+  std::unique_ptr<net::CookieMonster> cookie_store =
+      std::make_unique<net::CookieMonster>(
+          session_cleanup_cookie_store.get(), net_log,
+          first_party_sets_access_delegate_.is_enabled());
+  if (session_cleanup_cookie_store && params_->persist_session_cookies)
+    cookie_store->SetPersistSessionCookies(true);
 
-    builder.SetCookieStore(std::move(cookie_store));
+  if (params_->cookieable_schemes.has_value()) {
+    cookie_store->SetCookieableSchemes(
+        *params_->cookieable_schemes,
+        net::CookieStore::SetCookieableSchemesCallback());
   }
 
+  builder.SetCookieStore(std::move(cookie_store));
+
   if (base::FeatureList::IsEnabled(features::kTrustTokens)) {
     trust_token_store_ = std::make_unique<PendingTrustTokenStore>();
 
diff --git services/network/public/mojom/network_context.mojom services/network/public/mojom/network_context.mojom
index cd28ac0510e13..06a9dd17e776d 100644
--- services/network/public/mojom/network_context.mojom
+++ services/network/public/mojom/network_context.mojom
@@ -336,6 +336,9 @@ struct NetworkContextParams {
   // cookies. Otherwise it should be false.
   bool persist_session_cookies = false;
 
+  // Schemes that will be passed to CookieMonster::SetCookieableSchemes.
+  array<string>? cookieable_schemes;
+
   // True if an HTTP cache should be used.
   bool http_cache_enabled = true;
   // Maximum size of the HTTP cache. 0 means to use the default size.