mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-01 08:42:13 +00:00
f03fb58873
In the previous implementation, FetchEvent.preloadResponse is resolved when the response fetching finishes. However, ServiceWorker responding letency could be increased since waiting for preloadResponse finishes. The patch resolves FetchEvent.preloadResponse earlier when the response is available. The basic idea is to resolve the preload response when FetchInstance::OnResponseAvailableInternal() is called. Then propagating the response from the parent process main thread to the content process worker thread. This is achieved by IPC PFetchEventOp::Send/RecvPreloadResponse -> PFetchEventOpProxy::Send/RecvPreloadResponse. Since we can only get the response's ResourceTiming when FetchInstance::OnResponseEnd() is called. This patch introduces a new IPC method to propagate the ResourceTiming information from the parent process main thread to the content process worker thread. PFetchEventOp::Send/RecvPreloadResponseEnd -> PFetchEventOpProxy->Send/RecvPreloadResponseEnd. The tricky of this patch is we must extend the life cycle of FetchEventOp object if preloadResponse is set into FetchEvent. That because ServiceWorker could resolve FetchEvent.respondWith() by using FetchEvent.preloadResponse. In that case, FetchEventOp will get into a finish state and try to call FetchEventOpProxyChild::Senddelete with the operation result. However, the ResponseEnd could not be called at the moment, and we need to wait for the corresponding timing information and its end reason. To extend the life cycle of FetchEventOp, this patch cached the operation result while we get FetchEventOp::Callback is called. Then call FetchEventOpProxyChile::Senddelete() in FetchEventOpProxyChild::RecvPreloadResponseEnd() to close IPC. Or Senddelete() will be called while ActorDestroy() caused by shutdown. Differential Revision: https://phabricator.services.mozilla.com/D145338
73 lines
2.3 KiB
C++
73 lines
2.3 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef mozilla_dom_fetcheventopparent_h__
|
|
#define mozilla_dom_fetcheventopparent_h__
|
|
|
|
#include "nsISupports.h"
|
|
|
|
#include "mozilla/Tuple.h"
|
|
#include "mozilla/dom/FetchEventOpProxyParent.h"
|
|
#include "mozilla/dom/PFetchEventOpParent.h"
|
|
|
|
namespace mozilla::dom {
|
|
|
|
class FetchEventOpParent final : public PFetchEventOpParent {
|
|
friend class PFetchEventOpParent;
|
|
|
|
public:
|
|
NS_INLINE_DECL_REFCOUNTING(FetchEventOpParent)
|
|
|
|
FetchEventOpParent() = default;
|
|
|
|
// Transition from the Pending state to the Started state. Returns the preload
|
|
// response and response end args, if it has already arrived.
|
|
Tuple<Maybe<ParentToParentInternalResponse>, Maybe<ResponseEndArgs>> OnStart(
|
|
MovingNotNull<RefPtr<FetchEventOpProxyParent>> aFetchEventOpProxyParent);
|
|
|
|
// Transition from the Started state to the Finished state.
|
|
void OnFinish();
|
|
|
|
private:
|
|
~FetchEventOpParent() = default;
|
|
|
|
// IPDL methods
|
|
|
|
mozilla::ipc::IPCResult RecvPreloadResponse(
|
|
ParentToParentInternalResponse&& aResponse);
|
|
|
|
mozilla::ipc::IPCResult RecvPreloadResponseEnd(ResponseEndArgs&& aArgs);
|
|
|
|
void ActorDestroy(ActorDestroyReason) override;
|
|
|
|
struct Pending {
|
|
Maybe<ParentToParentInternalResponse> mPreloadResponse;
|
|
Maybe<ResponseEndArgs> mEndArgs;
|
|
};
|
|
|
|
struct Started {
|
|
NotNull<RefPtr<FetchEventOpProxyParent>> mFetchEventOpProxyParent;
|
|
};
|
|
|
|
struct Finished {};
|
|
|
|
using State = Variant<Pending, Started, Finished>;
|
|
|
|
// Tracks the state of the fetch event.
|
|
//
|
|
// Pending: the fetch event is waiting in RemoteWorkerController::mPendingOps
|
|
// and if the preload response arrives, we have to save it.
|
|
// Started: the FetchEventOpProxyParent has been created, and if the preload
|
|
// response arrives then we should forward it.
|
|
// Finished: the response has been propagated to the parent process, if the
|
|
// preload response arrives now then we simply drop it.
|
|
State mState = AsVariant(Pending());
|
|
};
|
|
|
|
} // namespace mozilla::dom
|
|
|
|
#endif // mozilla_dom_fetcheventopparent_h__
|