path: root/chromium/third_party/blink/renderer/core/loader/resource_load_observer_for_frame.cc

// Copyright 2019 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 "third_party/blink/renderer/core/loader/resource_load_observer_for_frame.h"

#include "third_party/blink/renderer/core/core_probes_inl.h"
#include "third_party/blink/renderer/core/frame/frame_console.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/frame/local_frame_client.h"
#include "third_party/blink/renderer/core/frame/web_feature.h"
#include "third_party/blink/renderer/core/inspector/inspector_trace_events.h"
#include "third_party/blink/renderer/core/loader/alternate_signed_exchange_resource_info.h"
#include "third_party/blink/renderer/core/loader/document_loader.h"
#include "third_party/blink/renderer/core/loader/frame_loader.h"
#include "third_party/blink/renderer/core/loader/frame_or_imported_document.h"
#include "third_party/blink/renderer/core/loader/idleness_detector.h"
#include "third_party/blink/renderer/core/loader/interactive_detector.h"
#include "third_party/blink/renderer/core/loader/mixed_content_checker.h"
#include "third_party/blink/renderer/core/loader/preload_helper.h"
#include "third_party/blink/renderer/core/loader/progress_tracker.h"
#include "third_party/blink/renderer/core/loader/subresource_filter.h"
#include "third_party/blink/renderer/platform/bindings/v8_dom_activity_logger.h"
#include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
#include "third_party/blink/renderer/platform/loader/fetch/fetch_client_settings_object.h"
#include "third_party/blink/renderer/platform/loader/fetch/fetch_initiator_info.h"
#include "third_party/blink/renderer/platform/loader/fetch/fetch_initiator_type_names.h"
#include "third_party/blink/renderer/platform/loader/fetch/fetch_parameters.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_loader_options.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_request.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_response.h"

namespace blink {

ResourceLoadObserverForFrame::ResourceLoadObserverForFrame(
    const FrameOrImportedDocument& frame_or_imported_document,
    const ResourceFetcherProperties& fetcher_properties)
    : frame_or_imported_document_(frame_or_imported_document),
      fetcher_properties_(fetcher_properties) {}
ResourceLoadObserverForFrame::~ResourceLoadObserverForFrame() = default;

void ResourceLoadObserverForFrame::DidStartRequest(
    const FetchParameters& params,
    ResourceType resource_type) {
  // TODO(yhirano): Consider removing ResourceLoadObserver::DidStartRequest
  // completely when we remove V8DOMActivityLogger.
  DocumentLoader* document_loader =
      frame_or_imported_document_->GetDocumentLoader();
  if (document_loader && !document_loader->Archive() &&
      params.Url().IsValid() && !params.IsSpeculativePreload()) {
    V8DOMActivityLogger* activity_logger = nullptr;
    const AtomicString& initiator_name = params.Options().initiator_info.name;
    if (initiator_name == fetch_initiator_type_names::kXmlhttprequest) {
      activity_logger = V8DOMActivityLogger::CurrentActivityLogger();
    } else {
      activity_logger =
          V8DOMActivityLogger::CurrentActivityLoggerIfIsolatedWorld();
    }
    if (activity_logger) {
      Vector<String> argv = {
          Resource::ResourceTypeToString(resource_type, initiator_name),
          params.Url()};
      activity_logger->LogEvent("blinkRequestResource", argv.size(),
                                argv.data());
    }
  }
}

void ResourceLoadObserverForFrame::WillSendRequest(
    uint64_t identifier,
    const ResourceRequest& request,
    const ResourceResponse& redirect_response,
    ResourceType resource_type,
    const FetchInitiatorInfo& initiator_info) {
  LocalFrame& frame = frame_or_imported_document_->GetFrame();
  if (redirect_response.IsNull()) {
    // Progress doesn't care about redirects, only notify it when an
    // initial request is sent.
    frame.Loader().Progress().WillStartLoading(identifier, request.Priority());
  }
  DocumentLoader& document_loader =
      frame_or_imported_document_->GetMasterDocumentLoader();
  Document& document = frame_or_imported_document_->GetDocument();
  probe::WillSendRequest(
      GetProbe(), identifier, &document_loader,
      fetcher_properties_->GetFetchClientSettingsObject().GlobalObjectUrl(),
      request, redirect_response, initiator_info, resource_type);
  if (auto* idleness_detector = frame.GetIdlenessDetector())
    idleness_detector->OnWillSendRequest(document.Fetcher());
  if (auto* interactive_detector = InteractiveDetector::From(document))
    interactive_detector->OnResourceLoadBegin(base::nullopt);
}

void ResourceLoadObserverForFrame::DidChangePriority(
    uint64_t identifier,
    ResourceLoadPriority priority,
    int intra_priority_value) {
  DocumentLoader& document_loader =
      frame_or_imported_document_->GetMasterDocumentLoader();
  TRACE_EVENT1("devtools.timeline", "ResourceChangePriority", "data",
               inspector_change_resource_priority_event::Data(
                   &document_loader, identifier, priority));
  probe::DidChangeResourcePriority(&frame_or_imported_document_->GetFrame(),
                                   &document_loader, identifier, priority);
}

void ResourceLoadObserverForFrame::DidReceiveResponse(
    uint64_t identifier,
    const ResourceRequest& request,
    const ResourceResponse& response,
    const Resource* resource,
    ResponseSource response_source) {
  LocalFrame& frame = frame_or_imported_document_->GetFrame();
  DocumentLoader& document_loader =
      frame_or_imported_document_->GetMasterDocumentLoader();
  LocalFrameClient* frame_client = frame.Client();
  SubresourceFilter* subresource_filter =
      document_loader.GetSubresourceFilter();
  if (subresource_filter && resource->GetResourceRequest().IsAdResource())
    subresource_filter->ReportAdRequestId(response.RequestId());

  DCHECK(frame_client);
  if (response.GetCTPolicyCompliance() ==
      ResourceResponse::kCTPolicyDoesNotComply) {
    CountUsage(
        frame.IsMainFrame()
            ? WebFeature::
                  kCertificateTransparencyNonCompliantSubresourceInMainFrame
            : WebFeature::
                  kCertificateTransparencyNonCompliantResourceInSubframe);
  }

  if (response_source == ResponseSource::kFromMemoryCache) {
    frame_client->DispatchDidLoadResourceFromMemoryCache(
        ResourceRequest(resource->GetResourceRequest()), response);

    // Note: probe::WillSendRequest needs to precede before this probe method.
    probe::MarkResourceAsCached(&frame, &document_loader, identifier);
    if (response.IsNull())
      return;
  }

  MixedContentChecker::CheckMixedPrivatePublic(&frame,
                                               response.RemoteIPAddress());

  std::unique_ptr<AlternateSignedExchangeResourceInfo> alternate_resource_info;

  // See if this is a prefetch for a SXG.
  if (response.IsSignedExchangeInnerResponse() &&
      resource->GetType() == ResourceType::kLinkPrefetch) {
    CountUsage(WebFeature::kLinkRelPrefetchForSignedExchanges);

    if (RuntimeEnabledFeatures::SignedExchangeSubresourcePrefetchEnabled(
            &frame_or_imported_document_->GetDocument()) &&
        resource->LastResourceResponse()) {
      // See if the outer response (which must be the last response in
      // the redirect chain) had provided alternate links for the prefetch.
      alternate_resource_info =
          AlternateSignedExchangeResourceInfo::CreateIfValid(
              resource->LastResourceResponse()->HttpHeaderField(
                  http_names::kLink),
              response.HttpHeaderField(http_names::kLink));
    }
  }

  PreloadHelper::CanLoadResources resource_loading_policy =
      response_source == ResponseSource::kFromMemoryCache
          ? PreloadHelper::kDoNotLoadResources
          : PreloadHelper::kLoadResourcesAndPreconnect;
  PreloadHelper::LoadLinksFromHeader(
      response.HttpHeaderField(http_names::kLink), response.CurrentRequestUrl(),
      frame, &frame_or_imported_document_->GetDocument(),
      resource_loading_policy, PreloadHelper::kLoadAll,
      nullptr /* viewport_description */, std::move(alternate_resource_info),
      base::OptionalOrNullptr(response.RecursivePrefetchToken()));

  if (response.HasMajorCertificateErrors()) {
    MixedContentChecker::HandleCertificateError(&frame, response,
                                                request.GetRequestContext());
  }

  if (response.IsLegacyTLSVersion()) {
    frame.Loader().ReportLegacyTLSVersion(
        response.CurrentRequestUrl(), true /* is_subresource */,
        resource->GetResourceRequest().IsAdResource());
  }

  frame.Loader().Progress().IncrementProgress(identifier, response);
  probe::DidReceiveResourceResponse(GetProbe(), identifier, &document_loader,
                                    response, resource);
  // It is essential that inspector gets resource response BEFORE console.
  frame.Console().ReportResourceResponseReceived(&document_loader, identifier,
                                                 response);
}

void ResourceLoadObserverForFrame::DidReceiveData(
    uint64_t identifier,
    base::span<const char> chunk) {
  LocalFrame& frame = frame_or_imported_document_->GetFrame();
  DocumentLoader& document_loader =
      frame_or_imported_document_->GetMasterDocumentLoader();
  frame.Loader().Progress().IncrementProgress(identifier, chunk.size());
  probe::DidReceiveData(GetProbe(), identifier, &document_loader, chunk.data(),
                        chunk.size());
}

void ResourceLoadObserverForFrame::DidReceiveTransferSizeUpdate(
    uint64_t identifier,
    int transfer_size_diff) {
  DCHECK_GT(transfer_size_diff, 0);
  DocumentLoader& document_loader =
      frame_or_imported_document_->GetMasterDocumentLoader();
  probe::DidReceiveEncodedDataLength(GetProbe(), &document_loader, identifier,
                                     transfer_size_diff);
}

void ResourceLoadObserverForFrame::DidDownloadToBlob(uint64_t identifier,
                                                     BlobDataHandle* blob) {
  if (blob) {
    probe::DidReceiveBlob(
        GetProbe(), identifier,
        &frame_or_imported_document_->GetMasterDocumentLoader(), blob);
  }
}

void ResourceLoadObserverForFrame::DidFinishLoading(
    uint64_t identifier,
    base::TimeTicks finish_time,
    int64_t encoded_data_length,
    int64_t decoded_body_length,
    bool should_report_corb_blocking) {
  LocalFrame& frame = frame_or_imported_document_->GetFrame();
  DocumentLoader& document_loader =
      frame_or_imported_document_->GetMasterDocumentLoader();
  frame.Loader().Progress().CompleteProgress(identifier);
  probe::DidFinishLoading(GetProbe(), identifier, &document_loader, finish_time,
                          encoded_data_length, decoded_body_length,
                          should_report_corb_blocking);

  Document& document = frame_or_imported_document_->GetDocument();
  if (auto* interactive_detector = InteractiveDetector::From(document)) {
    interactive_detector->OnResourceLoadEnd(finish_time);
  }
  if (LocalFrame* frame = document.GetFrame()) {
    if (IdlenessDetector* idleness_detector = frame->GetIdlenessDetector()) {
      idleness_detector->OnDidLoadResource();
    }
  }
  document.CheckCompleted();
}

void ResourceLoadObserverForFrame::DidFailLoading(
    const KURL&,
    uint64_t identifier,
    const ResourceError& error,
    int64_t,
    IsInternalRequest is_internal_request) {
  LocalFrame& frame = frame_or_imported_document_->GetFrame();
  DocumentLoader& document_loader =
      frame_or_imported_document_->GetMasterDocumentLoader();
  frame.Loader().Progress().CompleteProgress(identifier);
  probe::DidFailLoading(GetProbe(), identifier, &document_loader, error);

  // Notification to FrameConsole should come AFTER InspectorInstrumentation
  // call, DevTools front-end relies on this.
  if (!is_internal_request) {
    frame.Console().DidFailLoading(&document_loader, identifier, error);
  }
  Document& document = frame_or_imported_document_->GetDocument();
  if (auto* interactive_detector = InteractiveDetector::From(document)) {
    // We have not yet recorded load_finish_time. Pass nullopt here; we will
    // call base::TimeTicks::Now() lazily when we need it.
    interactive_detector->OnResourceLoadEnd(base::nullopt);
  }
  if (LocalFrame* frame = document.GetFrame()) {
    if (IdlenessDetector* idleness_detector = frame->GetIdlenessDetector()) {
      idleness_detector->OnDidLoadResource();
    }
  }
  document.CheckCompleted();
}

void ResourceLoadObserverForFrame::Trace(Visitor* visitor) {
  visitor->Trace(frame_or_imported_document_);
  visitor->Trace(fetcher_properties_);
  ResourceLoadObserver::Trace(visitor);
}

CoreProbeSink* ResourceLoadObserverForFrame::GetProbe() {
  return probe::ToCoreProbeSink(
      frame_or_imported_document_->GetFrame().GetDocument());
}

void ResourceLoadObserverForFrame::CountUsage(WebFeature feature) {
  frame_or_imported_document_->GetMasterDocumentLoader()
      .GetUseCounterHelper()
      .Count(feature, &frame_or_imported_document_->GetFrame());
}

}  // namespace blink