service_worker_main_resource_loader.cc

// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/service_worker/service_worker_main_resource_loader.h"

#include <optional>
#include <sstream>
#include <string>
#include <utility>

#include "base/check_is_test.h"
#include "base/containers/flat_set.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/field_trial_params.h"
#include "base/metrics/histogram_functions.h"
#include "base/notreached.h"
#include "base/strings/strcat.h"
#include "base/strings/string_split.h"
#include "base/time/time.h"
#include "base/timer/elapsed_timer.h"
#include "base/trace_event/common/trace_event_common.h"
#include "base/trace_event/trace_event.h"
#include "content/browser/loader/navigation_url_loader.h"
#include "content/browser/loader/response_head_update_params.h"
#include "content/browser/renderer_host/frame_tree_node.h"
#include "content/browser/service_worker/service_worker_client.h"
#include "content/browser/service_worker/service_worker_context_core.h"
#include "content/browser/service_worker/service_worker_context_wrapper.h"
#include "content/browser/service_worker/service_worker_loader_helpers.h"
#include "content/browser/service_worker/service_worker_metrics.h"
#include "content/browser/service_worker/service_worker_version.h"
#include "content/common/features.h"
#include "content/common/fetch/fetch_request_type_converters.h"
#include "content/common/service_worker/race_network_request_url_loader_client.h"
#include "content/common/service_worker/service_worker_resource_loader.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/common/content_features.h"
#include "net/base/load_timing_info.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_status_code.h"
#include "services/network/public/cpp/features.h"
#include "services/network/public/cpp/timing_allow_origin_parser.h"
#include "services/network/public/mojom/fetch_api.mojom.h"
#include "services/network/public/mojom/service_worker_router_info.mojom-shared.h"
#include "services/network/public/mojom/service_worker_router_info.mojom.h"
#include "third_party/blink/public/common/service_worker/service_worker_loader_helpers.h"
#include "third_party/blink/public/mojom/service_worker/service_worker_fetch_handler_bypass_option.mojom-shared.h"
#include "third_party/blink/public/mojom/use_counter/metrics/web_feature.mojom-shared.h"

namespace content {

namespace {

const char kHistogramLoadTiming[] = …;

std::string ComposeFetchEventResultString(
    ServiceWorkerFetchDispatcher::FetchEventResult result,
    const blink::mojom::FetchAPIResponse& response) { … }

const std::string ComposeNavigationTypeString(
    const network::ResourceRequest& resource_request) { … }

// Check the eligibility based on the allowlist. This doesn't mean the
// experiment is actually enabled. The eligibility is checked and UMA is
// reported for the analysis purpose.
bool HasAutoPreloadEligibleScript(scoped_refptr<ServiceWorkerVersion> version) { … }

std::string GetContainerHostClientId(int frame_tree_node_id) { … }

bool IsStaticRouterRaceRequestFixEnabled() { … }

}  // namespace

// This class waits for completion of a stream response from the service worker.
// It calls ServiceWorkerMainResourceLoader::CommitCompleted() upon completion
// of the response.
class ServiceWorkerMainResourceLoader::StreamWaiter
    : public blink::mojom::ServiceWorkerStreamCallback { … };

ServiceWorkerMainResourceLoader::ServiceWorkerMainResourceLoader(
    NavigationLoaderInterceptor::FallbackCallback fallback_callback,
    base::WeakPtr<ServiceWorkerClient> service_worker_client,
    int frame_tree_node_id,
    base::TimeTicks find_registration_start_time)
    : … { … }

ServiceWorkerMainResourceLoader::~ServiceWorkerMainResourceLoader() { … }

void ServiceWorkerMainResourceLoader::DetachedFromRequest() { … }

base::WeakPtr<ServiceWorkerMainResourceLoader>
ServiceWorkerMainResourceLoader::AsWeakPtr() { … }

void ServiceWorkerMainResourceLoader::StartRequest(
    const network::ResourceRequest& resource_request,
    mojo::PendingReceiver<network::mojom::URLLoader> receiver,
    mojo::PendingRemote<network::mojom::URLLoaderClient> client) { … }

void ServiceWorkerMainResourceLoader::MaybeDispatchPreload(
    RaceNetworkRequestMode race_network_request_mode,
    scoped_refptr<ServiceWorkerContextWrapper> context_wrapper,
    scoped_refptr<ServiceWorkerVersion> version) { … }

bool ServiceWorkerMainResourceLoader::MaybeStartAutoPreload(
    scoped_refptr<ServiceWorkerContextWrapper> context,
    scoped_refptr<ServiceWorkerVersion> version) { … }

bool ServiceWorkerMainResourceLoader::StartRaceNetworkRequest(
    scoped_refptr<ServiceWorkerContextWrapper> context,
    scoped_refptr<ServiceWorkerVersion> version) { … }

bool ServiceWorkerMainResourceLoader::MaybeStartNavigationPreload(
    scoped_refptr<ServiceWorkerContextWrapper> context_wrapper) { … }

void ServiceWorkerMainResourceLoader::CommitResponseHeaders(
    const network::mojom::URLResponseHeadPtr& response_head) { … }

void ServiceWorkerMainResourceLoader::CommitResponseBody(
    const network::mojom::URLResponseHeadPtr& response_head,
    mojo::ScopedDataPipeConsumerHandle response_body,
    std::optional<mojo_base::BigBuffer> cached_metadata) { … }

void ServiceWorkerMainResourceLoader::CommitEmptyResponseAndComplete() { … }

void ServiceWorkerMainResourceLoader::CommitCompleted(int error_code,
                                                      const char* reason) { … }

void ServiceWorkerMainResourceLoader::DidPrepareFetchEvent(
    scoped_refptr<ServiceWorkerVersion> version,
    blink::EmbeddedWorkerStatus initial_worker_status) { … }

void ServiceWorkerMainResourceLoader::DidDispatchFetchEvent(
    blink::ServiceWorkerStatusCode status,
    ServiceWorkerFetchDispatcher::FetchEventResult fetch_result,
    blink::mojom::FetchAPIResponsePtr response,
    blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
    blink::mojom::ServiceWorkerFetchEventTimingPtr timing,
    scoped_refptr<ServiceWorkerVersion> version) { … }

void ServiceWorkerMainResourceLoader::StartResponse(
    blink::mojom::FetchAPIResponsePtr response,
    scoped_refptr<ServiceWorkerVersion> version,
    blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream) { … }

void ServiceWorkerMainResourceLoader::HandleRedirect(
    const net::RedirectInfo& redirect_info,
    const network::mojom::URLResponseHeadPtr& response_head) { … }

// URLLoader implementation----------------------------------------

void ServiceWorkerMainResourceLoader::FollowRedirect(
    const std::vector<std::string>& removed_headers,
    const net::HttpRequestHeaders& modified_headers,
    const net::HttpRequestHeaders& modified_cors_exempt_headers,
    const std::optional<GURL>& new_url) { … }

void ServiceWorkerMainResourceLoader::SetPriority(
    net::RequestPriority priority,
    int32_t intra_priority_value) { … }

void ServiceWorkerMainResourceLoader::PauseReadingBodyFromNet() { … }

void ServiceWorkerMainResourceLoader::ResumeReadingBodyFromNet() { … }

void ServiceWorkerMainResourceLoader::OnBlobReadingComplete(int net_error) { … }

void ServiceWorkerMainResourceLoader::SetCommitResponsibility(
    FetchResponseFrom fetch_response_from) { … }

void ServiceWorkerMainResourceLoader::OnConnectionClosed() { … }

void ServiceWorkerMainResourceLoader::InvalidateAndDeleteIfNeeded() { … }

void ServiceWorkerMainResourceLoader::DeleteIfNeeded() { … }

network::mojom::ServiceWorkerStatus
ServiceWorkerMainResourceLoader::ConvertToServiceWorkerStatus(
    blink::EmbeddedWorkerStatus embedded_status,
    bool is_warming_up,
    bool is_warmed_up) { … }

std::string
ServiceWorkerMainResourceLoader::GetInitialServiceWorkerStatusString() { … }

std::string ServiceWorkerMainResourceLoader::GetFrameTreeNodeTypeString() { … }

void ServiceWorkerMainResourceLoader::
    RecordTimingMetricsForFetchHandlerHandledCase() { … }

void ServiceWorkerMainResourceLoader::
    RecordTimingMetricsForNetworkFallbackCase() { … }

void ServiceWorkerMainResourceLoader::
    RecordTimingMetricsForRaceNetworkRequestCase() { … }

bool ServiceWorkerMainResourceLoader::IsEligibleForRecordingTimingMetrics() { … }

void ServiceWorkerMainResourceLoader::RecordFindRegistrationToCompletedTrace() { … }

void ServiceWorkerMainResourceLoader::
    RecordFindRegistrationToRequestStartTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordRequestStartToForwardServiceWorkerTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordForwardServiceWorkerToWorkerReadyTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordWorkerReadyToFetchHandlerStartTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordFetchHandlerStartToFetchHandlerEndTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordFetchHandlerEndToResponseReceivedTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordResponseReceivedToCompletedTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordFindRegistrationToCompletedTiming() { … }

void ServiceWorkerMainResourceLoader::RecordRequestStartToCompletedTiming(
    const base::TimeTicks& request_start) { … }

void ServiceWorkerMainResourceLoader::
    RecordFindRegistrationToFallbackNetworkTiming() { … }

void ServiceWorkerMainResourceLoader::RecordStartToFallbackNetworkTiming() { … }

void ServiceWorkerMainResourceLoader::
    RecordFetchHandlerEndToFallbackNetworkTiming() { … }

void ServiceWorkerMainResourceLoader::RecordFetchEventHandlerMetrics(
    ServiceWorkerFetchDispatcher::FetchEventResult fetch_result) { … }

void ServiceWorkerMainResourceLoader::TransitionToStatus(Status new_status) { … }

bool ServiceWorkerMainResourceLoader::IsMainResourceLoader() { … }

ServiceWorkerMainResourceLoaderWrapper::ServiceWorkerMainResourceLoaderWrapper(
    std::unique_ptr<ServiceWorkerMainResourceLoader> loader)
    : … { … }

ServiceWorkerMainResourceLoaderWrapper::
    ~ServiceWorkerMainResourceLoaderWrapper() { … }

}  // namespace content
chromium/content/browser/service_worker/service_worker_main_resource_loader.cc
