From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- dom/performance/PerformanceMainThread.h | 234 ++++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) create mode 100644 dom/performance/PerformanceMainThread.h (limited to 'dom/performance/PerformanceMainThread.h') diff --git a/dom/performance/PerformanceMainThread.h b/dom/performance/PerformanceMainThread.h new file mode 100644 index 0000000000..46d7a339d1 --- /dev/null +++ b/dom/performance/PerformanceMainThread.h @@ -0,0 +1,234 @@ +/* -*- 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_PerformanceMainThread_h +#define mozilla_dom_PerformanceMainThread_h + +#include "Performance.h" +#include "PerformanceStorage.h" +#include "LargestContentfulPaint.h" +#include "nsTextFrame.h" + +namespace mozilla::dom { + +class PerformanceNavigationTiming; +class PerformanceEventTiming; + +using ImageLCPEntryMap = + nsTHashMap>; + +using TextFrameUnions = nsTHashMap, nsRect>; + +class PerformanceMainThread final : public Performance, + public PerformanceStorage { + public: + PerformanceMainThread(nsPIDOMWindowInner* aWindow, + nsDOMNavigationTiming* aDOMTiming, + nsITimedChannel* aChannel); + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(PerformanceMainThread, + Performance) + + PerformanceStorage* AsPerformanceStorage() override { return this; } + + virtual PerformanceTiming* Timing() override; + + virtual PerformanceNavigation* Navigation() override; + + virtual void AddEntry(nsIHttpChannel* channel, + nsITimedChannel* timedChannel) override; + + // aData must be non-null. + virtual void AddEntry(const nsString& entryName, + const nsString& initiatorType, + UniquePtr&& aData) override; + + // aPerformanceTimingData must be non-null. + void AddRawEntry(UniquePtr aPerformanceTimingData, + const nsAString& aInitiatorType, + const nsAString& aEntryName); + virtual void SetFCPTimingEntry(PerformancePaintTiming* aEntry) override; + bool HadFCPTimingEntry() const { return mFCPTiming; } + + void InsertEventTimingEntry(PerformanceEventTiming*) override; + void BufferEventTimingEntryIfNeeded(PerformanceEventTiming*) override; + void DispatchPendingEventTimingEntries() override; + + void BufferLargestContentfulPaintEntryIfNeeded(LargestContentfulPaint*); + + TimeStamp CreationTimeStamp() const override; + + DOMHighResTimeStamp CreationTime() const override; + + virtual void GetMozMemory(JSContext* aCx, + JS::MutableHandle aObj) override; + + virtual nsDOMNavigationTiming* GetDOMTiming() const override { + return mDOMTiming; + } + + virtual uint64_t GetRandomTimelineSeed() override { + return GetDOMTiming()->GetRandomTimelineSeed(); + } + + virtual nsITimedChannel* GetChannel() const override { return mChannel; } + + // The GetEntries* methods need to be overriden in order to add the + // the document entry of type navigation. + virtual void GetEntries(nsTArray>& aRetval) override; + + // Return entries which qualify availableFromTimeline boolean check + virtual void GetEntriesByType( + const nsAString& aEntryType, + nsTArray>& aRetval) override; + + // There are entries that we don't want expose via performance, however + // we do want PerformanceObserver to get them + void GetEntriesByTypeForObserver( + const nsAString& aEntryType, + nsTArray>& aRetval) override; + virtual void GetEntriesByName( + const nsAString& aName, const Optional& aEntryType, + nsTArray>& aRetval) override; + + void UpdateNavigationTimingEntry() override; + void QueueNavigationTimingEntry() override; + void QueueLargestContentfulPaintEntry(LargestContentfulPaint* aEntry); + + size_t SizeOfEventEntries(mozilla::MallocSizeOf aMallocSizeOf) const override; + + static constexpr uint32_t kDefaultEventTimingBufferSize = 150; + static constexpr uint32_t kDefaultEventTimingDurationThreshold = 104; + static constexpr double kDefaultEventTimingMinDuration = 16.0; + + static constexpr uint32_t kMaxLargestContentfulPaintBufferSize = 150; + + class EventCounts* EventCounts() override; + + bool IsGlobalObjectWindow() const override { return true; }; + + bool HasDispatchedInputEvent() const { return mHasDispatchedInputEvent; } + + void SetHasDispatchedScrollEvent(); + bool HasDispatchedScrollEvent() const { return mHasDispatchedScrollEvent; } + + void ProcessElementTiming(); + + void AddImagesPendingRendering(ImagePendingRendering aImagePendingRendering) { + mImagesPendingRendering.AppendElement(aImagePendingRendering); + } + + void StoreImageLCPEntry(Element* aElement, imgRequestProxy* aImgRequestProxy, + LargestContentfulPaint* aEntry); + + already_AddRefed GetImageLCPEntry( + Element* aElement, imgRequestProxy* aImgRequestProxy); + + bool UpdateLargestContentfulPaintSize(double aSize); + double GetLargestContentfulPaintSize() const { + return mLargestContentfulPaintSize; + } + + nsTHashMap, nsRect>& GetTextFrameUnions() { + return mTextFrameUnions; + } + + void FinalizeLCPEntriesForText(); + + void ClearGeneratedTempDataForLCP(); + + protected: + ~PerformanceMainThread(); + + void CreateNavigationTimingEntry(); + + void InsertUserEntry(PerformanceEntry* aEntry) override; + + DOMHighResTimeStamp GetPerformanceTimingFromString( + const nsAString& aTimingName) override; + + void DispatchBufferFullEvent() override; + + RefPtr mDocEntry; + RefPtr mDOMTiming; + nsCOMPtr mChannel; + RefPtr mTiming; + RefPtr mNavigation; + RefPtr mFCPTiming; + JS::Heap mMozMemory; + + nsTArray> mEventTimingEntries; + nsTArray> mLargestContentfulPaintEntries; + + AutoCleanLinkedList> + mPendingEventTimingEntries; + bool mHasDispatchedInputEvent = false; + bool mHasDispatchedScrollEvent = false; + + RefPtr mFirstInputEvent; + RefPtr mPendingPointerDown; + + private: + void SetHasDispatchedInputEvent(); + + bool mHasQueuedRefreshdriverObserver = false; + + RefPtr mEventCounts; + void IncEventCount(const nsAtom* aType); + + PresShell* GetPresShell(); + + nsTArray mImagesPendingRendering; + + // The key is the pair of the element initiates the image loading + // and the imgRequestProxy of the image, and the value is + // the LCP entry for this image. When the image is + // completely loaded, we add it to mImageLCPEntryMap. + // Later, when the image is painted, we get the LCP entry from it + // to update the size and queue the entry if needed. + // + // When the initiating element is disconnected from the document, + // we keep the orphan entry because if the same memory address is + // reused by a different LCP candidate, it'll update + // mImageLCPEntryMap precedes before it tries to get the LCP entry. + ImageLCPEntryMap mImageLCPEntryMap; + + // Keeps track of the rendered size of the largest contentful paint that + // we have processed so far. + double mLargestContentfulPaintSize = 0.0; + + // When a text frame is painted, its area (relative to the + // containing block) is unioned with other text frames that + // belong to the same containing block. + // mTextFrameUnions's key is the containing block, and + // the value is the unioned area. + TextFrameUnions mTextFrameUnions; +}; + +inline void ImplCycleCollectionTraverse( + nsCycleCollectionTraversalCallback& aCallback, ImageLCPEntryMap& aField, + const char* aName, uint32_t aFlags = 0) { + for (auto& entry : aField) { + RefPtr* lcpEntry = entry.GetModifiableData(); + ImplCycleCollectionTraverse(aCallback, *lcpEntry, "ImageLCPEntryMap.mData", + aCallback.Flags()); + } +} + +inline void ImplCycleCollectionTraverse( + nsCycleCollectionTraversalCallback& aCallback, TextFrameUnions& aField, + const char* aName, uint32_t aFlags = 0) { + for (auto& entry : aField) { + ImplCycleCollectionTraverse( + aCallback, entry, "TextFrameUnions's key (nsRefPtrHashKey)", + aFlags); + } +} + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceMainThread_h -- cgit v1.2.3