Quelle LargestContentfulPaint.cpp Sprache: 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/. */
#include "mozilla/dom/Element.h"
#include "nsContentUtils.h"
#include "nsLayoutUtils.h"
#include "nsRFPService.h"
#include "Performance.h"
#include "imgRequest.h"
#include "PerformanceMainThread.h"
#include "LargestContentfulPaint.h"

#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/DOMIntersectionObserver.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/Element.h"

#include "mozilla/PresShell.h"
#include "mozilla/Logging.h"
#include "mozilla/nsVideoFrame.h"

namespace mozilla::dom {

static LazyLogModule gLCPLogging("LargestContentfulPaint");

#define LOG(...) MOZ_LOG(gLCPLogging, LogLevel::Debug, (__VA_ARGS__))

NS_IMPL_CYCLE_COLLECTION_INHERITED(LargestContentfulPaint, PerformanceEntry,
                                   mPerformance, mURI, mElement)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(LargestContentfulPaint)
NS_INTERFACE_MAP_END_INHERITING(PerformanceEntry)

NS_IMPL_ADDREF_INHERITED(LargestContentfulPaint, PerformanceEntry)
NS_IMPL_RELEASE_INHERITED(LargestContentfulPaint, PerformanceEntry)

static double GetAreaInDoublePixelsFromAppUnits(const nsSize& aSize) {
  return NSAppUnitsToDoublePixels(aSize.Width(), AppUnitsPerCSSPixel()) *
         NSAppUnitsToDoublePixels(aSize.Height(), AppUnitsPerCSSPixel());
}

static double GetAreaInDoublePixelsFromAppUnits(const nsRect& aRect) {
  return NSAppUnitsToDoublePixels(aRect.Width(), AppUnitsPerCSSPixel()) *
         NSAppUnitsToDoublePixels(aRect.Height(), AppUnitsPerCSSPixel());
}

static DOMHighResTimeStamp GetReducedTimePrecisionDOMHighRes(
    Performance* aPerformance, const TimeStamp& aRawTimeStamp) {
  MOZ_ASSERT(aPerformance);
  DOMHighResTimeStamp rawValue =
      aPerformance->GetDOMTiming()->TimeStampToDOMHighRes(aRawTimeStamp);
  return nsRFPService::ReduceTimePrecisionAsMSecs(
      rawValue, aPerformance->GetRandomTimelineSeed(),
      aPerformance->GetRTPCallerType());
}

LargestContentfulPaint::LargestContentfulPaint(
    PerformanceMainThread* aPerformance, const TimeStamp& aRenderTime,
    const Maybe<TimeStamp>& aLoadTime, const unsigned long aSize, nsIURI* aURI,
    Element* aElement, bool aShouldExposeRenderTime)
    : PerformanceEntry(aPerformance->GetParentObject(), u""_ns,
                       kLargestContentfulPaintName),
      mPerformance(aPerformance),
      mRenderTime(aRenderTime),
      mLoadTime(aLoadTime),
      mShouldExposeRenderTime(aShouldExposeRenderTime),
      mSize(aSize),
      mURI(aURI) {
  MOZ_ASSERT(mPerformance);
  MOZ_ASSERT(aElement);
  // The element could be a pseudo-element
  if (aElement->ChromeOnlyAccess()) {
    mElement = do_GetWeakReference(Element::FromNodeOrNull(
        aElement->FindFirstNonChromeOnlyAccessContent()));
  } else {
    mElement = do_GetWeakReference(aElement);
  }

  if (const Element* element = GetElement()) {
    mId = element->GetID();
  }
}

JSObject* LargestContentfulPaint::WrapObject(
    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
  return LargestContentfulPaint_Binding::Wrap(aCx, this, aGivenProto);
}

Element* LargestContentfulPaint::GetElement() const {
  nsCOMPtr<Element> element = do_QueryReferent(mElement);
  return element ? nsContentUtils::GetAnElementForTiming(
                       element, element->GetComposedDoc(), nullptr)
                 : nullptr;
}

void LargestContentfulPaint::BufferEntryIfNeeded() {
  mPerformance->BufferLargestContentfulPaintEntryIfNeeded(this);
}

/* static*/
bool LCPHelpers::IsQualifiedImageRequest(imgRequest* aRequest,
                                         Element* aContainingElement) {
  MOZ_ASSERT(aContainingElement);
  if (!aRequest) {
    return false;
  }

  if (aRequest->IsChrome()) {
    return false;
  }

  if (!aContainingElement->ChromeOnlyAccess()) {
    return true;
  }

  // Exception: this is a poster image of video element
  if (nsIContent* parent = aContainingElement->GetParent()) {
    nsVideoFrame* videoFrame = do_QueryFrame(parent->GetPrimaryFrame());
    if (videoFrame && videoFrame->GetPosterImage() == aContainingElement) {
      return true;
    }
  }

  // Exception: CSS generated images
  if (aContainingElement->IsInNativeAnonymousSubtree()) {
    if (nsINode* rootParentOrHost =
            aContainingElement
                ->GetClosestNativeAnonymousSubtreeRootParentOrHost()) {
      if (!rootParentOrHost->ChromeOnlyAccess()) {
        return true;
      }
    }
  }
  return false;
}
void LargestContentfulPaint::MaybeProcessImageForElementTiming(
    imgRequestProxy* aRequest, Element* aElement) {
  if (!StaticPrefs::dom_enable_largest_contentful_paint()) {
    return;
  }

  MOZ_ASSERT(aRequest);
  imgRequest* request = aRequest->GetOwner();
  if (!LCPHelpers::IsQualifiedImageRequest(request, aElement)) {
    return;
  }

  Document* document = aElement->GetComposedDoc();
  if (!document) {
    return;
  }

  nsPresContext* pc =
      aElement->GetPresContext(Element::PresContextFor::eForComposedDoc);
  if (!pc) {
    return;
  }

  PerformanceMainThread* performance = pc->GetPerformanceMainThread();
  if (!performance) {
    return;
  }

  if (MOZ_UNLIKELY(MOZ_LOG_TEST(gLCPLogging, LogLevel::Debug))) {
    nsCOMPtr<nsIURI> uri;
    aRequest->GetURI(getter_AddRefs(uri));
    LOG("MaybeProcessImageForElementTiming, Element=%p, URI=%s, "
        "performance=%p ",
        aElement, uri ? uri->GetSpecOrDefault().get() : "", performance);
  }

  aElement->SetFlags(ELEMENT_IN_CONTENT_IDENTIFIER_FOR_LCP);

  nsTArray<WeakPtr<PreloaderBase>>& imageRequestProxiesForElement =
      document->ContentIdentifiersForLCP().LookupOrInsert(aElement);

  if (imageRequestProxiesForElement.Contains(aRequest)) {
    LOG(" The content identifier existed for element=%p and request=%p, "
        "return.",
        aElement, aRequest);
    return;
  }

  imageRequestProxiesForElement.AppendElement(aRequest);

#ifdef DEBUG
  uint32_t status = imgIRequest::STATUS_NONE;
  aRequest->GetImageStatus(&status);
  MOZ_ASSERT(status & imgIRequest::STATUS_LOAD_COMPLETE);
#endif

  // At this point, the loadTime of the image is known, but
  // the renderTime is unknown, so it's added to ImagesPendingRendering
  // as a placeholder, and the corresponding LCP entry will be created
  // when the renderTime is known.
  // Here we are exposing the load time of the image which could be
  // a privacy concern. The spec talks about it at
  // https://wicg.github.io/element-timing/#sec-security
  // TLDR: The similar metric can be obtained by ResourceTiming
  // API and onload handlers already, so this is not exposing anything
  // new.
  LOG(" Added a pending image rendering");
  performance->AddImagesPendingRendering(
      ImagePendingRendering{aElement, aRequest, TimeStamp::Now()});
}

bool LCPHelpers::CanFinalizeLCPEntry(const nsIFrame* aFrame) {
  if (!StaticPrefs::dom_enable_largest_contentful_paint()) {
    return false;
  }

  if (!aFrame) {
    return false;
  }

  nsPresContext* presContext = aFrame->PresContext();
  return !presContext->HasStoppedGeneratingLCP() &&
         presContext->GetPerformanceMainThread();
}

void LCPHelpers::FinalizeLCPEntryForImage(
    Element* aContainingBlock, imgRequestProxy* aImgRequestProxy,
    const nsRect& aTargetRectRelativeToSelf) {
  LOG("FinalizeLCPEntryForImage element=%p image=%p", aContainingBlock,
      aImgRequestProxy);
  if (!aImgRequestProxy) {
    return;
  }

  if (!IsQualifiedImageRequest(aImgRequestProxy->GetOwner(),
                               aContainingBlock)) {
    return;
  }

  nsIFrame* frame = aContainingBlock->GetPrimaryFrame();

  if (!CanFinalizeLCPEntry(frame)) {
    return;
  }

  PerformanceMainThread* performance =
      frame->PresContext()->GetPerformanceMainThread();
  MOZ_ASSERT(performance);

  if (performance->HasDispatchedInputEvent() ||
      performance->HasDispatchedScrollEvent()) {
    return;
  }

  if (!performance->IsPendingLCPCandidate(aContainingBlock, aImgRequestProxy)) {
    return;
  }

  imgRequestProxy::LCPTimings& lcpTimings = aImgRequestProxy->GetLCPTimings();
  if (!lcpTimings.AreSet()) {
    return;
  }

  imgRequest* request = aImgRequestProxy->GetOwner();
  MOZ_ASSERT(request);

  nsCOMPtr<nsIURI> requestURI;
  aImgRequestProxy->GetURI(getter_AddRefs(requestURI));

  const bool taoPassed =
      request->ShouldReportRenderTimeForLCP() || request->IsData();

  RefPtr<LargestContentfulPaint> entry = new LargestContentfulPaint(
      performance, lcpTimings.mRenderTime.ref(), lcpTimings.mLoadTime, 0,
      requestURI, aContainingBlock, taoPassed);

  entry->UpdateSize(aContainingBlock, aTargetRectRelativeToSelf, performance,
                    true);

  // Resets the LCPTiming so that unless this (element, image) pair goes
  // through PerformanceMainThread::ProcessElementTiming again, they
  // won't generate new LCP entries.
  lcpTimings.Reset();

  // If area is less than or equal to document’s largest contentful paint size,
  // return.
  if (!performance->UpdateLargestContentfulPaintSize(entry->Size())) {
    LOG(

        " This paint(%lu) is not greater than the largest paint (%lf)that "
        "we've "
        "reported so far, return",
        entry->Size(), performance->GetLargestContentfulPaintSize());
    return;
  }

  entry->QueueEntry();
}

DOMHighResTimeStamp LargestContentfulPaint::RenderTime() const {
  if (!mShouldExposeRenderTime) {
    return 0;
  }
  return GetReducedTimePrecisionDOMHighRes(mPerformance, mRenderTime);
}

DOMHighResTimeStamp LargestContentfulPaint::LoadTime() const {
  if (mLoadTime.isNothing()) {
    return 0;
  }

  return GetReducedTimePrecisionDOMHighRes(mPerformance, mLoadTime.ref());
}

DOMHighResTimeStamp LargestContentfulPaint::StartTime() const {
  if (mShouldExposeRenderTime) {
    return GetReducedTimePrecisionDOMHighRes(mPerformance, mRenderTime);
  }

  if (mLoadTime.isNothing()) {
    return 0;
  }

  return GetReducedTimePrecisionDOMHighRes(mPerformance, mLoadTime.ref());
}

/* static */
Element* LargestContentfulPaint::GetContainingBlockForTextFrame(
    const nsTextFrame* aTextFrame) {
  nsIFrame* containingFrame = aTextFrame->GetContainingBlock();
  MOZ_ASSERT(containingFrame);
  return Element::FromNodeOrNull(containingFrame->GetContent());
}

void LargestContentfulPaint::QueueEntry() {
  LOG("QueueEntry entry=%p", this);
  mPerformance->QueueLargestContentfulPaintEntry(this);

  ReportLCPToNavigationTimings();
}

void LargestContentfulPaint::GetUrl(nsAString& aUrl) {
  if (mURI) {
    CopyUTF8toUTF16(mURI->GetSpecOrDefault(), aUrl);
  }
}

void LargestContentfulPaint::UpdateSize(
    const Element* aContainingBlock, const nsRect& aTargetRectRelativeToSelf,
    const PerformanceMainThread* aPerformance, bool aIsImage) {
  nsIFrame* frame = aContainingBlock->GetPrimaryFrame();
  MOZ_ASSERT(frame);

  nsIFrame* rootFrame = frame->PresShell()->GetRootFrame();
  if (!rootFrame) {
    return;
  }

  if (frame->Style()->IsInOpacityZeroSubtree()) {
    LOG(" Opacity:0 return");
    return;
  }

  // The following size computation is based on a pending pull request
  // https://github.com/w3c/largest-contentful-paint/pull/99

  // Let visibleDimensions be concreteDimensions, adjusted for positioning
  // by object-position or background-position and element’s content box.
  const nsRect& visibleDimensions = aTargetRectRelativeToSelf;

  // Let clientContentRect be the smallest DOMRectReadOnly containing
  // visibleDimensions with element’s transforms applied.
  nsRect clientContentRect = nsLayoutUtils::TransformFrameRectToAncestor(
      frame, visibleDimensions, rootFrame);

  // Let intersectionRect be the value returned by the intersection rect
  // algorithm using element as the target and viewport as the root.
  // (From https://wicg.github.io/element-timing/#sec-report-image-element)
  IntersectionInput input = DOMIntersectionObserver::ComputeInput(
      *frame->PresContext()->Document(), rootFrame->GetContent(), nullptr);
  const IntersectionOutput output =
      DOMIntersectionObserver::Intersect(input, *aContainingBlock);

  Maybe<nsRect> intersectionRect = output.mIntersectionRect;

  if (intersectionRect.isNothing()) {
    LOG(" The intersectionRect is nothing for Element=%p. return.",
        aContainingBlock);
    return;
  }

  // Let intersectingClientContentRect be the intersection of clientContentRect
  // with intersectionRect.
  Maybe<nsRect> intersectionWithContentRect =
      clientContentRect.EdgeInclusiveIntersection(intersectionRect.value());

  if (intersectionWithContentRect.isNothing()) {
    LOG(" The intersectionWithContentRect is nothing for Element=%p. return.",
        aContainingBlock);
    return;
  }

  nsRect renderedRect = intersectionWithContentRect.value();

  double area = GetAreaInDoublePixelsFromAppUnits(renderedRect);

  double viewport = GetAreaInDoublePixelsFromAppUnits(input.mRootRect);

  LOG(" Viewport = %f, RenderRect = %f.", viewport, area);
  // We don't want to report things that take the entire viewport.
  if (area >= viewport) {
    LOG(" The renderedRect is at least same as the area of the "
        "viewport for Element=%p, return.",
        aContainingBlock);
    return;
  }

  Maybe<nsSize> intrinsicSize = frame->GetIntrinsicSize().ToSize();
  const bool hasIntrinsicSize = intrinsicSize && !intrinsicSize->IsEmpty();

  if (aIsImage && hasIntrinsicSize) {
    //  Let (naturalWidth, naturalHeight) be imageRequest’s natural dimension.
    //  Let naturalArea be naturalWidth * naturalHeight.
    double naturalArea =
        GetAreaInDoublePixelsFromAppUnits(intrinsicSize.value());

    LOG(" naturalArea = %f", naturalArea);

    // Let boundingClientArea be clientContentRect’s width * clientContentRect’s
    // height.
    double boundingClientArea =
        NSAppUnitsToDoublePixels(clientContentRect.Width(),
                                 AppUnitsPerCSSPixel()) *
        NSAppUnitsToDoublePixels(clientContentRect.Height(),
                                 AppUnitsPerCSSPixel());
    LOG(" boundingClientArea = %f", boundingClientArea);

    // Let scaleFactor be boundingClientArea / naturalArea.
    double scaleFactor = boundingClientArea / naturalArea;
    LOG(" scaleFactor = %f", scaleFactor);

    // If scaleFactor is greater than 1, then divide area by scaleFactor.
    if (scaleFactor > 1) {
      LOG(" area before sacled doown %f", area);
      area = area / scaleFactor;
    }
  }

  MOZ_ASSERT(!mSize);
  mSize = area;
}

void LCPTextFrameHelper::MaybeUnionTextFrame(
    nsTextFrame* aTextFrame, const nsRect& aRelativeToSelfRect) {
  if (!StaticPrefs::dom_enable_largest_contentful_paint() ||
      aTextFrame->PresContext()->HasStoppedGeneratingLCP()) {
    return;
  }

  Element* containingBlock =
      LargestContentfulPaint::GetContainingBlockForTextFrame(aTextFrame);
  if (!containingBlock ||
      // If element is contained in doc’s set of elements with rendered text,
      // continue
      containingBlock->HasFlag(ELEMENT_PROCESSED_BY_LCP_FOR_TEXT) ||
      containingBlock->ChromeOnlyAccess()) {
    return;
  }

  MOZ_ASSERT(containingBlock->GetPrimaryFrame());

  PerformanceMainThread* perf =
      aTextFrame->PresContext()->GetPerformanceMainThread();
  if (!perf) {
    return;
  }

  auto& unionRect = perf->GetTextFrameUnions().LookupOrInsert(containingBlock);
  unionRect = unionRect.Union(aRelativeToSelfRect);
}

void LCPHelpers::FinalizeLCPEntryForText(
    PerformanceMainThread* aPerformance, const TimeStamp& aRenderTime,
    Element* aContainingBlock, const nsRect& aTargetRectRelativeToSelf,
    const nsPresContext* aPresContext) {
  MOZ_ASSERT(aPerformance);
  LOG("FinalizeLCPEntryForText element=%p", aContainingBlock);

  if (!aContainingBlock->GetPrimaryFrame()) {
    return;
  }
  MOZ_ASSERT(CanFinalizeLCPEntry(aContainingBlock->GetPrimaryFrame()));
  MOZ_ASSERT(!aContainingBlock->HasFlag(ELEMENT_PROCESSED_BY_LCP_FOR_TEXT));
  MOZ_ASSERT(!aContainingBlock->ChromeOnlyAccess());

  aContainingBlock->SetFlags(ELEMENT_PROCESSED_BY_LCP_FOR_TEXT);

  RefPtr<LargestContentfulPaint> entry = new LargestContentfulPaint(
      aPerformance, aRenderTime, Nothing(), 0, nullptr, aContainingBlock, true);

  entry->UpdateSize(aContainingBlock, aTargetRectRelativeToSelf, aPerformance,
                    false);
  // If area is less than or equal to document’s largest contentful paint size,
  // return.
  if (!aPerformance->UpdateLargestContentfulPaintSize(entry->Size())) {
    LOG(" This paint(%lu) is not greater than the largest paint (%lf)that "
        "we've "
        "reported so far, return",
        entry->Size(), aPerformance->GetLargestContentfulPaintSize());
    return;
  }
  entry->QueueEntry();
}

void LargestContentfulPaint::ReportLCPToNavigationTimings() {
  nsCOMPtr<Element> element = do_QueryReferent(mElement);
  if (!element) {
    return;
  }

  const Document* document = element->OwnerDoc();

  MOZ_ASSERT(document);

  nsDOMNavigationTiming* timing = document->GetNavigationTiming();

  if (MOZ_UNLIKELY(!timing)) {
    return;
  }

  if (document->IsResourceDoc()) {
    return;
  }

  if (BrowsingContext* browsingContext = document->GetBrowsingContext()) {
    if (browsingContext->GetEmbeddedInContentDocument()) {
      return;
    }
  }

  if (!document->IsTopLevelContentDocument()) {
    return;
  }
  timing->NotifyLargestContentfulRenderForRootContentDocument(
      GetReducedTimePrecisionDOMHighRes(mPerformance, mRenderTime));
}
}  // namespace mozilla::dom

quality100%

¤ Dauer der Verarbeitung: 0.19 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.