diff --git a/patches/chromium/.patches b/patches/chromium/.patches index ea93d4b16f160..8f51a2d3ba7ef 100644 --- a/patches/chromium/.patches +++ b/patches/chromium/.patches @@ -114,4 +114,5 @@ cherry-pick-2e7c9b33453b.patch move_networkstateobserver_from_document_to_window.patch cherry-pick-0894af410c4e.patch cherry-pick-91dd4f79ab5b.patch +cherry-pick-1a8af2da50e4.patch cherry-pick-a5f54612590d.patch diff --git a/patches/chromium/cherry-pick-1a8af2da50e4.patch b/patches/chromium/cherry-pick-1a8af2da50e4.patch new file mode 100644 index 0000000000000..019693b353c5e --- /dev/null +++ b/patches/chromium/cherry-pick-1a8af2da50e4.patch @@ -0,0 +1,354 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Lukasz Anforowicz +Date: Mon, 8 Nov 2021 15:05:30 +0000 +Subject: Deleting unused field: `FetchEventPreloadHandle::url_loader`. +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +The `FetchEventPreloadHandle::url_loader` field is not really used - it +is only needed to keep the URLLoader alive (and this can be accomplished +in a simpler way, by keeping the mojo::PendingRemote in the Browser +process). + +This CL removes the `FetchEventPreloadHandle::url_loader` field and the +FetchEventPreloadHandle and WebFetchEventPreloadHandle types (collapsing +these handle types into their only other remaining field: +mojo::PendingReceiver). + +(cherry picked from commit dbe67ccde52e30acf6a66b1b9cc83768a067fa6a) + +Fixed: 1264477 +Change-Id: I9c9c54900d79e92ac08eeb43536c938fa84a58f8 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3252914 +Reviewed-by: Daniel Cheng +Reviewed-by: Ben Kelly +Reviewed-by: Hiroki Nakagawa +Commit-Queue: Łukasz Anforowicz +Cr-Original-Commit-Position: refs/heads/main@{#937895} +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3262600 +Bot-Commit: Rubber Stamper +Commit-Queue: Ben Kelly +Cr-Commit-Position: refs/branch-heads/4664@{#853} +Cr-Branched-From: 24dc4ee75e01a29d390d43c9c264372a169273a7-refs/heads/main@{#929512} + +diff --git a/content/browser/service_worker/service_worker_fetch_dispatcher.cc b/content/browser/service_worker/service_worker_fetch_dispatcher.cc +index 0d034293826354f6d1b7910a6604f241ff1c8988..b980c5a0745eaf7a904c1047cbe6c5e86cef0c67 100644 +--- a/content/browser/service_worker/service_worker_fetch_dispatcher.cc ++++ b/content/browser/service_worker/service_worker_fetch_dispatcher.cc +@@ -449,8 +449,10 @@ class ServiceWorkerFetchDispatcher::URLLoaderAssets + // NetworkService. + URLLoaderAssets( + scoped_refptr shared_url_loader_factory, ++ mojo::PendingRemote url_loader, + std::unique_ptr url_loader_client) + : shared_url_loader_factory_(std::move(shared_url_loader_factory)), ++ url_loader_(std::move(url_loader)), + url_loader_client_(std::move(url_loader_client)) {} + + void MaybeReportToDevTools(std::pair worker_id, +@@ -467,6 +469,7 @@ class ServiceWorkerFetchDispatcher::URLLoaderAssets + + // NetworkService: + scoped_refptr shared_url_loader_factory_; ++ mojo::PendingRemote url_loader_; + + // Both: + std::unique_ptr url_loader_client_; +@@ -633,7 +636,8 @@ void ServiceWorkerFetchDispatcher::DispatchFetchEvent() { + auto params = blink::mojom::DispatchFetchEventParams::New(); + params->request = std::move(request_); + params->client_id = client_id_; +- params->preload_handle = std::move(preload_handle_); ++ params->preload_url_loader_client_receiver = ++ std::move(preload_url_loader_client_receiver_); + params->is_offline_capability_check = is_offline_capability_check_; + + // TODO(https://crbug.com/900700): Make the remote connected to a receiver +@@ -721,13 +725,9 @@ bool ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload( + // When the fetch event is for an offline capability check, respond to the + // navigation preload with a network disconnected error, to simulate offline. + if (is_offline_capability_check_) { +- mojo::PendingRemote url_loader_to_pass; + mojo::Remote url_loader_client; +- auto dummy_receiver = url_loader_to_pass.InitWithNewPipeAndPassReceiver(); + +- preload_handle_ = blink::mojom::FetchEventPreloadHandle::New(); +- preload_handle_->url_loader = std::move(url_loader_to_pass); +- preload_handle_->url_loader_client_receiver = ++ preload_url_loader_client_receiver_ = + url_loader_client.BindNewPipeAndPassReceiver(); + + url_loader_client->OnComplete( +@@ -770,12 +770,10 @@ bool ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload( + factory = base::MakeRefCounted( + std::move(network_factory)); + +- preload_handle_ = blink::mojom::FetchEventPreloadHandle::New(); +- + // Create the DelegatingURLLoaderClient, which becomes the + // URLLoaderClient for the navigation preload network request. + mojo::PendingRemote inner_url_loader_client; +- preload_handle_->url_loader_client_receiver = ++ preload_url_loader_client_receiver_ = + inner_url_loader_client.InitWithNewPipeAndPassReceiver(); + auto url_loader_client = std::make_unique( + std::move(inner_url_loader_client), resource_request); +@@ -810,11 +808,9 @@ bool ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload( + net::MutableNetworkTrafficAnnotationTag( + kNavigationPreloadTrafficAnnotation)); + +- preload_handle_->url_loader = std::move(url_loader); +- + DCHECK(!url_loader_assets_); + url_loader_assets_ = base::MakeRefCounted( +- std::move(factory), std::move(url_loader_client)); ++ std::move(factory), std::move(url_loader), std::move(url_loader_client)); + return true; + } + +diff --git a/content/browser/service_worker/service_worker_fetch_dispatcher.h b/content/browser/service_worker/service_worker_fetch_dispatcher.h +index 5b2a45bff25b7f2c35e304385f22935c33d60a05..b96b2de068bf9f6a38b4d995cf137ebfd53735ea 100644 +--- a/content/browser/service_worker/service_worker_fetch_dispatcher.h ++++ b/content/browser/service_worker/service_worker_fetch_dispatcher.h +@@ -121,10 +121,11 @@ class CONTENT_EXPORT ServiceWorkerFetchDispatcher { + + scoped_refptr url_loader_assets_; + +- // |preload_handle_| holds the URLLoader and URLLoaderClient for the service +- // worker to receive the navigation preload response. It's passed to the +- // service worker along with the fetch event. +- blink::mojom::FetchEventPreloadHandlePtr preload_handle_; ++ // Holds the URLLoaderClient for the service worker to receive the navigation ++ // preload response. It's passed to the service worker along with the fetch ++ // event. ++ mojo::PendingReceiver ++ preload_url_loader_client_receiver_; + + // Whether to dispatch an offline-capability-check fetch event. + const bool is_offline_capability_check_ = false; +diff --git a/content/renderer/service_worker/navigation_preload_request.cc b/content/renderer/service_worker/navigation_preload_request.cc +index c9e9ffd4c68a583569fd5633ca2369e190e2aed7..92f9d4a7de115cac0502aeb9c777605a756b6175 100644 +--- a/content/renderer/service_worker/navigation_preload_request.cc ++++ b/content/renderer/service_worker/navigation_preload_request.cc +@@ -19,12 +19,12 @@ NavigationPreloadRequest::NavigationPreloadRequest( + ServiceWorkerContextClient* owner, + int fetch_event_id, + const GURL& url, +- blink::mojom::FetchEventPreloadHandlePtr preload_handle) ++ mojo::PendingReceiver ++ preload_url_loader_client_receiver) + : owner_(owner), + fetch_event_id_(fetch_event_id), + url_(url), +- url_loader_(std::move(preload_handle->url_loader)), +- receiver_(this, std::move(preload_handle->url_loader_client_receiver)) {} ++ receiver_(this, std::move(preload_url_loader_client_receiver)) {} + + NavigationPreloadRequest::~NavigationPreloadRequest() = default; + +diff --git a/content/renderer/service_worker/navigation_preload_request.h b/content/renderer/service_worker/navigation_preload_request.h +index 08cfc4a0dad5777b88f2388da5d07c864d9953fd..f6d19a3d1383767e1c450be7ec29a47ff245ff5a 100644 +--- a/content/renderer/service_worker/navigation_preload_request.h ++++ b/content/renderer/service_worker/navigation_preload_request.h +@@ -35,7 +35,8 @@ class NavigationPreloadRequest final : public network::mojom::URLLoaderClient { + ServiceWorkerContextClient* owner, + int fetch_event_id, + const GURL& url, +- blink::mojom::FetchEventPreloadHandlePtr preload_handle); ++ mojo::PendingReceiver ++ preload_url_loader_client_receiver); + ~NavigationPreloadRequest() override; + + // network::mojom::URLLoaderClient: +@@ -59,11 +60,10 @@ class NavigationPreloadRequest final : public network::mojom::URLLoaderClient { + void ReportErrorToOwner(const std::string& message, + blink::WebServiceWorkerError::Mode error_mode); + +- ServiceWorkerContextClient* owner_; ++ ServiceWorkerContextClient* owner_ = nullptr; + +- const int fetch_event_id_; ++ const int fetch_event_id_ = -1; + const GURL url_; +- mojo::Remote url_loader_; + mojo::Receiver receiver_; + + std::unique_ptr response_; +diff --git a/content/renderer/service_worker/service_worker_context_client.cc b/content/renderer/service_worker/service_worker_context_client.cc +index d569c5362c0c3866b333db714d7dd8e7f3344afc..f65f535b5c228ce881a0b0066b67d9847b6168a4 100644 +--- a/content/renderer/service_worker/service_worker_context_client.cc ++++ b/content/renderer/service_worker/service_worker_context_client.cc +@@ -476,14 +476,14 @@ void ServiceWorkerContextClient::SendWorkerStarted( + void ServiceWorkerContextClient::SetupNavigationPreload( + int fetch_event_id, + const blink::WebURL& url, +- std::unique_ptr preload_handle) { ++ blink::CrossVariantMojoReceiver< ++ network::mojom::URLLoaderClientInterfaceBase> ++ preload_url_loader_client_receiver) { + DCHECK(worker_task_runner_->RunsTasksInCurrentSequence()); + DCHECK(context_); + auto preload_request = std::make_unique( + this, fetch_event_id, GURL(url), +- blink::mojom::FetchEventPreloadHandle::New( +- std::move(preload_handle->url_loader), +- std::move(preload_handle->url_loader_client_receiver))); ++ std::move(preload_url_loader_client_receiver)); + context_->preload_requests.AddWithID(std::move(preload_request), + fetch_event_id); + } +diff --git a/content/renderer/service_worker/service_worker_context_client.h b/content/renderer/service_worker/service_worker_context_client.h +index 8191aaec6ed37c6a64bcbd9beac720777de3075e..5abd533c6c3b1926efa6b8fc158562468cc96e19 100644 +--- a/content/renderer/service_worker/service_worker_context_client.h ++++ b/content/renderer/service_worker/service_worker_context_client.h +@@ -159,8 +159,9 @@ class CONTENT_EXPORT ServiceWorkerContextClient + const blink::WebString& source_url) override; + void SetupNavigationPreload(int fetch_event_id, + const blink::WebURL& url, +- std::unique_ptr +- preload_handle) override; ++ blink::CrossVariantMojoReceiver< ++ network::mojom::URLLoaderClientInterfaceBase> ++ preload_url_loader_client_receiver) override; + void RequestTermination(RequestTerminationCallback callback) override; + scoped_refptr + CreateWorkerFetchContextOnInitiatorThread() override; +diff --git a/mojo/public/cpp/bindings/README.md b/mojo/public/cpp/bindings/README.md +index b950df5a7733b26ae3a9dbc1bacc208e584fa9e6..334ba1c8fd92aed36dec6993afe38ca91ffcc49a 100644 +--- a/mojo/public/cpp/bindings/README.md ++++ b/mojo/public/cpp/bindings/README.md +@@ -1709,6 +1709,9 @@ C++ sources can depend on shared sources only, by referencing the + `"${target_name}_shared"` target, e.g. `"//foo/mojom:mojom_shared"` in the + example above. + ++For converting between Blink and non-Blink variants, please see ++`//third_party/blink/public/platform/cross_variant_mojo_util.h`. ++ + ## Versioning Considerations + + For general documentation of versioning in the Mojom IDL see +diff --git a/third_party/blink/public/mojom/service_worker/dispatch_fetch_event_params.mojom b/third_party/blink/public/mojom/service_worker/dispatch_fetch_event_params.mojom +index 382be0b3dd042ceadb73e4d514f93ac7c8624b43..c95a2e255166871ff45b6a4c3a8b206e1dace776 100644 +--- a/third_party/blink/public/mojom/service_worker/dispatch_fetch_event_params.mojom ++++ b/third_party/blink/public/mojom/service_worker/dispatch_fetch_event_params.mojom +@@ -9,13 +9,6 @@ import "third_party/blink/public/mojom/blob/blob.mojom"; + import "third_party/blink/public/mojom/fetch/fetch_api_request.mojom"; + import "third_party/blink/public/mojom/timing/worker_timing_container.mojom"; + +-// Used for service worker navigation preload, to create +-// FetchEvent#preloadResponse. +-struct FetchEventPreloadHandle { +- pending_remote url_loader; +- pending_receiver url_loader_client_receiver; +-}; +- + // Parameters used for dispatching a FetchEvent. + struct DispatchFetchEventParams { + // FetchEvent#request. +@@ -23,8 +16,9 @@ struct DispatchFetchEventParams { + + // FetchEvent#clientId. + string client_id; ++ + // FetchEvent#preloadResponse. +- FetchEventPreloadHandle? preload_handle; ++ pending_receiver? preload_url_loader_client_receiver; + + // This is currently null for navigation because it's still being implemented. + // TODO(https://crbug.com/900700): Make this non-nullable when implementation +diff --git a/third_party/blink/public/web/modules/service_worker/web_service_worker_context_client.h b/third_party/blink/public/web/modules/service_worker/web_service_worker_context_client.h +index 67c0c9d3cb10478755422b489c97afe8adce1a24..0a8cde9a7f6bab9de2c43f13c1bc0d35375bc2b5 100644 +--- a/third_party/blink/public/web/modules/service_worker/web_service_worker_context_client.h ++++ b/third_party/blink/public/web/modules/service_worker/web_service_worker_context_client.h +@@ -31,8 +31,6 @@ + #ifndef THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_SERVICE_WORKER_WEB_SERVICE_WORKER_CONTEXT_CLIENT_H_ + #define THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_SERVICE_WORKER_WEB_SERVICE_WORKER_CONTEXT_CLIENT_H_ + +-#include +- + #include "base/memory/scoped_refptr.h" + #include "services/network/public/mojom/url_loader.mojom-shared.h" + #include "third_party/blink/public/mojom/devtools/console_message.mojom-shared.h" +@@ -53,14 +51,6 @@ namespace blink { + class WebServiceWorkerContextProxy; + class WebString; + +-// Used to pass the mojom struct blink.mojom.FetchEventPreloadHandle across the +-// boundary between //content and Blink. +-struct WebFetchEventPreloadHandle { +- CrossVariantMojoRemote url_loader; +- CrossVariantMojoReceiver +- url_loader_client_receiver; +-}; +- + // WebServiceWorkerContextClient is a "client" of a service worker execution + // context. This interface is implemented by the embedder and allows the + // embedder to communicate with the service worker execution context. It is +@@ -166,7 +156,8 @@ class WebServiceWorkerContextClient { + virtual void SetupNavigationPreload( + int fetch_event_id, + const WebURL& url, +- std::unique_ptr preload_handle) {} ++ CrossVariantMojoReceiver ++ preload_url_loader_client_receiver) {} + + // Called when we need to request to terminate this worker due to idle + // timeout. +diff --git a/third_party/blink/renderer/modules/service_worker/service_worker_global_scope.cc b/third_party/blink/renderer/modules/service_worker/service_worker_global_scope.cc +index 9c2cff1d0433d55c4b08fd4eef83544bd120425b..3e84a0200950a33c93f6e473a2cace4609389aea 100644 +--- a/third_party/blink/renderer/modules/service_worker/service_worker_global_scope.cc ++++ b/third_party/blink/renderer/modules/service_worker/service_worker_global_scope.cc +@@ -1514,11 +1514,12 @@ void ServiceWorkerGlobalScope::StartFetchEvent( + params->request->url.ElidedString().Utf8()); + + // Set up for navigation preload (FetchEvent#preloadResponse) if needed. +- const bool navigation_preload_sent = !!params->preload_handle; ++ bool navigation_preload_sent = !!params->preload_url_loader_client_receiver; + if (navigation_preload_sent) { + To(ReportingProxy()) +- .SetupNavigationPreload(event_id, params->request->url, +- std::move(params->preload_handle)); ++ .SetupNavigationPreload( ++ event_id, params->request->url, ++ std::move(params->preload_url_loader_client_receiver)); + } + + ScriptState::Scope scope(ScriptController()->GetScriptState()); +diff --git a/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.cc b/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.cc +index b2efbea7c370b7f641cad9c5db75f9826ec705ed..33d11a19b350e1dd12c105403ed513e9a62a76ec 100644 +--- a/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.cc ++++ b/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.cc +@@ -257,14 +257,11 @@ bool ServiceWorkerGlobalScopeProxy::IsServiceWorkerGlobalScopeProxy() const { + void ServiceWorkerGlobalScopeProxy::SetupNavigationPreload( + int fetch_event_id, + const KURL& url, +- mojom::blink::FetchEventPreloadHandlePtr preload_handle) { ++ mojo::PendingReceiver ++ preload_url_loader_client_receiver) { + DCHECK_CALLED_ON_VALID_THREAD(worker_thread_checker_); +- auto web_preload_handle = std::make_unique(); +- web_preload_handle->url_loader = std::move(preload_handle->url_loader); +- web_preload_handle->url_loader_client_receiver = +- std::move(preload_handle->url_loader_client_receiver); +- Client().SetupNavigationPreload(fetch_event_id, url, +- std::move(web_preload_handle)); ++ Client().SetupNavigationPreload( ++ fetch_event_id, url, std::move(preload_url_loader_client_receiver)); + } + + void ServiceWorkerGlobalScopeProxy::RequestTermination( +diff --git a/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.h b/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.h +index 783dbe1919d1282f40117aea22b75a8e54e82d89..d54a2449da63f67930cb3d85cfbb27c35c45a8d3 100644 +--- a/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.h ++++ b/third_party/blink/renderer/modules/service_worker/service_worker_global_scope_proxy.h +@@ -129,7 +129,8 @@ class ServiceWorkerGlobalScopeProxy final : public WebServiceWorkerContextProxy, + void SetupNavigationPreload( + int fetch_event_id, + const KURL& url, +- mojom::blink::FetchEventPreloadHandlePtr preload_handle); ++ mojo::PendingReceiver ++ preload_url_loader_client_receiver); + void RequestTermination(WTF::CrossThreadOnceFunction callback); + + // Detaches this proxy object entirely from the outside world, clearing out