diff options
Diffstat (limited to '')
71 files changed, 9327 insertions, 0 deletions
diff --git a/dom/performance/EventCounts.cpp b/dom/performance/EventCounts.cpp new file mode 100644 index 0000000000..b94545e913 --- /dev/null +++ b/dom/performance/EventCounts.cpp @@ -0,0 +1,79 @@ +/* -*- 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 "nsIGlobalObject.h" +#include "EventCounts.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/EventCounts.h" +#include "mozilla/dom/PerformanceEventTimingBinding.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(EventCounts, mParent) + +static const EventMessage sQualifiedEventType[36] = { + EventMessage::eMouseAuxClick, + EventMessage::eMouseClick, + EventMessage::eContextMenu, + EventMessage::eMouseDoubleClick, + EventMessage::eMouseDown, + EventMessage::eMouseEnter, + EventMessage::eMouseLeave, + EventMessage::eMouseOut, + EventMessage::eMouseOver, + EventMessage::eMouseUp, + EventMessage::ePointerOver, + EventMessage::ePointerEnter, + EventMessage::ePointerDown, + EventMessage::ePointerUp, + EventMessage::ePointerCancel, + EventMessage::ePointerOut, + EventMessage::ePointerLeave, + EventMessage::ePointerGotCapture, + EventMessage::ePointerLostCapture, + EventMessage::eTouchStart, + EventMessage::eTouchEnd, + EventMessage::eTouchCancel, + EventMessage::eKeyDown, + EventMessage::eKeyPress, + EventMessage::eKeyUp, + EventMessage::eEditorBeforeInput, + EventMessage::eEditorInput, + EventMessage::eCompositionStart, + EventMessage::eCompositionUpdate, + EventMessage::eCompositionEnd, + EventMessage::eDragStart, + EventMessage::eDragEnd, + EventMessage::eDragEnter, + EventMessage::eDragLeave, + EventMessage::eDragOver, + EventMessage::eDrop}; + +EventCounts::EventCounts(nsISupports* aParent) : mParent(aParent) { + ErrorResult rv; + + for (const EventMessage& eventType : sQualifiedEventType) { + EventCounts_Binding::MaplikeHelpers::Set( + this, nsDependentString(Event::GetEventName(eventType)), 0, rv); + if (NS_WARN_IF(rv.Failed())) { + rv.SuppressException(); +#ifdef DEBUG + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject()); + if (global) { + MOZ_ASSERT(global->IsDying()); + } +#endif + return; + } + } +} + +JSObject* EventCounts::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return EventCounts_Binding::Wrap(aCx, this, aGivenProto); +} +} // namespace mozilla::dom diff --git a/dom/performance/EventCounts.h b/dom/performance/EventCounts.h new file mode 100644 index 0000000000..59d9c140fc --- /dev/null +++ b/dom/performance/EventCounts.h @@ -0,0 +1,31 @@ +/* -*- 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_PerformanceEventCounts_h___ +#define mozilla_dom_PerformanceEventCounts_h___ + +#include "nsCOMPtr.h" +#include "nsWrapperCache.h" + +namespace mozilla::dom { +class EventCounts final : public nsWrapperCache { + public: + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(EventCounts) + NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(EventCounts) + + explicit EventCounts(nsISupports* aParent); + + nsISupports* GetParentObject() const { return mParent; } + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + private: + ~EventCounts() = default; + nsCOMPtr<nsISupports> mParent; +}; +} // namespace mozilla::dom +#endif diff --git a/dom/performance/LargestContentfulPaint.cpp b/dom/performance/LargestContentfulPaint.cpp new file mode 100644 index 0000000000..3382a2fbad --- /dev/null +++ b/dom/performance/LargestContentfulPaint.cpp @@ -0,0 +1,565 @@ +/* -*- 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()); +} + +ImagePendingRendering::ImagePendingRendering( + const LCPImageEntryKey& aLCPImageEntryKey, const TimeStamp& aLoadTime) + : mLCPImageEntryKey(aLCPImageEntryKey), mLoadTime(aLoadTime) {} + +LargestContentfulPaint::LargestContentfulPaint( + PerformanceMainThread* aPerformance, const TimeStamp& aRenderTime, + const Maybe<TimeStamp>& aLoadTime, const unsigned long aSize, nsIURI* aURI, + Element* aElement, const Maybe<const LCPImageEntryKey>& aLCPImageEntryKey, + bool aShouldExposeRenderTime) + : PerformanceEntry(aPerformance->GetParentObject(), u""_ns, + kLargestContentfulPaintName), + mPerformance(aPerformance), + mRenderTime(aRenderTime), + mLoadTime(aLoadTime), + mShouldExposeRenderTime(aShouldExposeRenderTime), + mSize(aSize), + mURI(aURI), + mLCPImageEntryKey(aLCPImageEntryKey) { + 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() { + MOZ_ASSERT(mLCPImageEntryKey.isNothing()); + 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); + } + + const LCPImageEntryKey entryKey = LCPImageEntryKey(aElement, aRequest); + if (!document->ContentIdentifiersForLCP().EnsureInserted(entryKey)) { + LOG(" The content identifier existed for element=%p and request=%p, " + "return.", + aElement, aRequest); + return; + } + +#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{entryKey, 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", aContainingBlock); + 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); + + RefPtr<LargestContentfulPaint> entry = + performance->GetImageLCPEntry(aContainingBlock, aImgRequestProxy); + if (!entry) { + LOG(" No Image Entry"); + return; + } + entry->UpdateSize(aContainingBlock, aTargetRectRelativeToSelf, performance, + true); + // 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::CreateLCPEntryForImage( + PerformanceMainThread* aPerformance, Element* aElement, + imgRequestProxy* aRequestProxy, const TimeStamp& aLoadTime, + const TimeStamp& aRenderTime, const LCPImageEntryKey& aImageEntryKey) { + MOZ_ASSERT(StaticPrefs::dom_enable_largest_contentful_paint()); + MOZ_ASSERT(aRequestProxy); + MOZ_ASSERT(aPerformance); + if (MOZ_UNLIKELY(MOZ_LOG_TEST(gLCPLogging, LogLevel::Debug))) { + nsCOMPtr<nsIURI> uri; + aRequestProxy->GetURI(getter_AddRefs(uri)); + LOG("CreateLCPEntryForImage " + "Element=%p, aRequestProxy=%p, URI=%s loadTime=%f, " + "aRenderTime=%f\n", + aElement, aRequestProxy, uri->GetSpecOrDefault().get(), + GetReducedTimePrecisionDOMHighRes(aPerformance, aLoadTime), + GetReducedTimePrecisionDOMHighRes(aPerformance, aRenderTime)); + } + if (aPerformance->HasDispatchedInputEvent() || + aPerformance->HasDispatchedScrollEvent()) { + return; + } + + // Let url be the empty string. + // If imageRequest is not null, set url to be imageRequest’s request URL. + nsCOMPtr<nsIURI> requestURI; + aRequestProxy->GetURI(getter_AddRefs(requestURI)); + + imgRequest* request = aRequestProxy->GetOwner(); + // We should never get here unless request is valid. + MOZ_ASSERT(request); + + bool taoPassed = request->ShouldReportRenderTimeForLCP() || request->IsData(); + // https://wicg.github.io/element-timing/#report-image-element-timing + // For TAO failed requests, the renderTime is exposed as 0 for + // security reasons. + // + // At this point, we have all the information about the entry + // except the size. + RefPtr<LargestContentfulPaint> entry = new LargestContentfulPaint( + aPerformance, aRenderTime, Some(aLoadTime), 0, requestURI, aElement, + Some(aImageEntryKey), taoPassed); + + LOG(" Upsert a LargestContentfulPaint entry=%p to LCPEntryMap.", + entry.get()); + aPerformance->StoreImageLCPEntry(aElement, aRequestProxy, entry); +} + +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, Nothing(), 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 diff --git a/dom/performance/LargestContentfulPaint.h b/dom/performance/LargestContentfulPaint.h new file mode 100644 index 0000000000..0193cd858a --- /dev/null +++ b/dom/performance/LargestContentfulPaint.h @@ -0,0 +1,236 @@ +/* -*- 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_LargestContentfulPaint_h___ +#define mozilla_dom_LargestContentfulPaint_h___ + +#include "nsCycleCollectionParticipant.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/PerformanceEntry.h" +#include "mozilla/dom/PerformanceLargestContentfulPaintBinding.h" + +#include "imgRequestProxy.h" + +class nsTextFrame; +namespace mozilla::dom { + +static constexpr nsLiteralString kLargestContentfulPaintName = + u"largest-contentful-paint"_ns; + +class Performance; +class PerformanceMainThread; + +struct LCPImageEntryKey { + LCPImageEntryKey(Element* aElement, imgRequestProxy* aImgRequestProxy) + : mElement(do_GetWeakReference(aElement)), + mImageRequestProxy(aImgRequestProxy) { + MOZ_ASSERT(aElement); + MOZ_ASSERT(aImgRequestProxy); + + mHash = mozilla::HashGeneric(reinterpret_cast<uintptr_t>(aElement), + reinterpret_cast<uintptr_t>(aImgRequestProxy)); + } + + LCPImageEntryKey(const LCPImageEntryKey& aLCPImageEntryKey) { + mElement = aLCPImageEntryKey.mElement; + mImageRequestProxy = aLCPImageEntryKey.mImageRequestProxy; + mHash = aLCPImageEntryKey.mHash; + } + + Element* GetElement() const { + nsCOMPtr<Element> element = do_QueryReferent(mElement); + return element; + } + + imgRequestProxy* GetImgRequestProxy() const { + return static_cast<imgRequestProxy*>(mImageRequestProxy.get()); + } + + bool operator==(const LCPImageEntryKey& aOther) const { + imgRequestProxy* imgRequest = GetImgRequestProxy(); + if (!imgRequest) { + return false; + } + + imgRequestProxy* otherImgRequest = aOther.GetImgRequestProxy(); + if (!otherImgRequest) { + return false; + } + + Element* element = GetElement(); + if (!element) { + return false; + } + + Element* otherElement = aOther.GetElement(); + if (!otherElement) { + return false; + } + + return element == otherElement && imgRequest == otherImgRequest; + } + + bool Equals(const Element* aElement, + const imgRequestProxy* aImgRequestProxy) const { + Element* element = GetElement(); + if (!element || !mImageRequestProxy) { + return false; + } + + return element == aElement && mImageRequestProxy == mImageRequestProxy; + } + + nsWeakPtr mElement; + + WeakPtr<PreloaderBase> mImageRequestProxy; + + PLDHashNumber mHash = 0; + + ~LCPImageEntryKey() = default; +}; + +struct LCPTextFrameHelper final { + static void MaybeUnionTextFrame(nsTextFrame* aTextFrame, + const nsRect& aRelativeToSelfRect); +}; + +class ImagePendingRendering final { + public: + ImagePendingRendering(const LCPImageEntryKey& aLCPImageEntryKey, + const TimeStamp& aLoadTime); + + Element* GetElement() const { return mLCPImageEntryKey.GetElement(); } + + imgRequestProxy* GetImgRequestProxy() const { + return mLCPImageEntryKey.GetImgRequestProxy(); + } + + LCPImageEntryKey mLCPImageEntryKey; + TimeStamp mLoadTime; +}; + +class LCPEntryHashEntry : public PLDHashEntryHdr { + public: + typedef const LCPImageEntryKey& KeyType; + typedef const LCPImageEntryKey* KeyTypePointer; + + explicit LCPEntryHashEntry(KeyTypePointer aKey) : mKey(*aKey) {} + LCPEntryHashEntry(LCPEntryHashEntry&&) = default; + + ~LCPEntryHashEntry() = default; + + bool KeyEquals(KeyTypePointer aKey) const { return mKey == *aKey; } + + KeyType GetKey() const { return mKey; } + + static KeyTypePointer KeyToPointer(KeyType& aKey) { return &aKey; } + + static PLDHashNumber HashKey(KeyTypePointer aKey) { return aKey->mHash; } + enum { ALLOW_MEMMOVE = true }; + + LCPImageEntryKey mKey; +}; + +class LCPHelpers final { + public: + // Creates the LCP Entry for images with all information except the size of + // the element. The size of the image is unknown at the moment. The entry is + // not going to be queued in this function. + static void CreateLCPEntryForImage( + PerformanceMainThread* aPerformance, Element* aElement, + imgRequestProxy* aRequestProxy, const TimeStamp& aLoadTime, + const TimeStamp& aRenderTime, const LCPImageEntryKey& aContentIdentifier); + + // Called when the size of the image is known. + static void FinalizeLCPEntryForImage(Element* aContainingBlock, + imgRequestProxy* aImgRequestProxy, + const nsRect& aTargetRectRelativeToSelf); + + static void FinalizeLCPEntryForText(PerformanceMainThread* aPerformance, + const TimeStamp& aRenderTime, + Element* aContainingBlock, + const nsRect& aTargetRectRelativeToSelf, + const nsPresContext* aPresContext); + + static bool IsQualifiedImageRequest(imgRequest* aRequest, + Element* aContainingElement); + + private: + static bool CanFinalizeLCPEntry(const nsIFrame* aFrame); +}; + +// https://w3c.github.io/largest-contentful-paint/ +class LargestContentfulPaint final : public PerformanceEntry { + public: + NS_DECL_ISUPPORTS_INHERITED + + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(LargestContentfulPaint, + PerformanceEntry) + + LargestContentfulPaint(PerformanceMainThread* aPerformance, + const TimeStamp& aRenderTime, + const Maybe<TimeStamp>& aLoadTime, + const unsigned long aSize, nsIURI* aURI, + Element* aElement, + const Maybe<const LCPImageEntryKey>& aLCPImageEntryKey, + bool aShouldExposeRenderTime); + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + DOMHighResTimeStamp RenderTime() const; + DOMHighResTimeStamp LoadTime() const; + DOMHighResTimeStamp StartTime() const override; + + unsigned long Size() const { return mSize; } + void GetId(nsAString& aId) const { + if (mId) { + mId->ToString(aId); + } + } + void GetUrl(nsAString& aUrl); + + Element* GetElement() const; + + static Element* GetContainingBlockForTextFrame(const nsTextFrame* aTextFrame); + + void UpdateSize(const Element* aContainingBlock, + const nsRect& aTargetRectRelativeToSelf, + const PerformanceMainThread* aPerformance, bool aIsImage); + + void BufferEntryIfNeeded() override; + + static void MaybeProcessImageForElementTiming(imgRequestProxy* aRequest, + Element* aElement); + + void QueueEntry(); + + Maybe<LCPImageEntryKey>& GetLCPImageEntryKey() { return mLCPImageEntryKey; } + + private: + ~LargestContentfulPaint() = default; + + void ReportLCPToNavigationTimings(); + + RefPtr<PerformanceMainThread> mPerformance; + + // This is always set but only exposed to web content if + // mShouldExposeRenderTime is true. + const TimeStamp mRenderTime; + const Maybe<TimeStamp> mLoadTime; + // This is set to false when for security reasons web content it not allowed + // to see the RenderTime. + const bool mShouldExposeRenderTime; + unsigned long mSize; + nsCOMPtr<nsIURI> mURI; + + nsWeakPtr mElement; + RefPtr<nsAtom> mId; + + Maybe<LCPImageEntryKey> mLCPImageEntryKey; +}; +} // namespace mozilla::dom +#endif diff --git a/dom/performance/Performance.cpp b/dom/performance/Performance.cpp new file mode 100644 index 0000000000..ecbc3b4c68 --- /dev/null +++ b/dom/performance/Performance.cpp @@ -0,0 +1,1045 @@ +/* -*- 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 "Performance.h" + +#include <sstream> + +#include "ETWTools.h" +#include "GeckoProfiler.h" +#include "nsRFPService.h" +#include "PerformanceEntry.h" +#include "PerformanceMainThread.h" +#include "PerformanceMark.h" +#include "PerformanceMeasure.h" +#include "PerformanceObserver.h" +#include "PerformanceResourceTiming.h" +#include "PerformanceService.h" +#include "PerformanceWorker.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/dom/MessagePortBinding.h" +#include "mozilla/dom/PerformanceBinding.h" +#include "mozilla/dom/PerformanceEntryEvent.h" +#include "mozilla/dom/PerformanceNavigationBinding.h" +#include "mozilla/dom/PerformanceObserverBinding.h" +#include "mozilla/dom/PerformanceNavigationTiming.h" +#include "mozilla/IntegerPrintfMacros.h" +#include "mozilla/Preferences.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/WorkerPrivate.h" +#include "mozilla/dom/WorkerRunnable.h" +#include "mozilla/dom/WorkerScope.h" + +#define PERFLOG(msg, ...) printf_stderr(msg, ##__VA_ARGS__) + +namespace mozilla::dom { + +enum class Performance::ResolveTimestampAttribute { + Start, + End, + Duration, +}; + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Performance) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +NS_IMPL_CYCLE_COLLECTION_INHERITED(Performance, DOMEventTargetHelper, + mUserEntries, mResourceEntries, + mSecondaryResourceEntries, mObservers); + +NS_IMPL_ADDREF_INHERITED(Performance, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(Performance, DOMEventTargetHelper) + +/* static */ +already_AddRefed<Performance> Performance::CreateForMainThread( + nsPIDOMWindowInner* aWindow, nsIPrincipal* aPrincipal, + nsDOMNavigationTiming* aDOMTiming, nsITimedChannel* aChannel) { + MOZ_ASSERT(NS_IsMainThread()); + + MOZ_ASSERT(aWindow->AsGlobal()); + RefPtr<Performance> performance = + new PerformanceMainThread(aWindow, aDOMTiming, aChannel); + return performance.forget(); +} + +/* static */ +already_AddRefed<Performance> Performance::CreateForWorker( + WorkerGlobalScope* aGlobalScope) { + MOZ_ASSERT(aGlobalScope); + // aWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<Performance> performance = new PerformanceWorker(aGlobalScope); + return performance.forget(); +} + +/* static */ +already_AddRefed<Performance> Performance::Get(JSContext* aCx, + nsIGlobalObject* aGlobal) { + RefPtr<Performance> performance; + if (NS_IsMainThread()) { + nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal); + if (!window) { + return nullptr; + } + + performance = window->GetPerformance(); + return performance.forget(); + } + + const WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx); + if (!workerPrivate) { + return nullptr; + } + + WorkerGlobalScope* scope = workerPrivate->GlobalScope(); + MOZ_ASSERT(scope); + performance = scope->GetPerformance(); + + return performance.forget(); +} + +Performance::Performance(nsIGlobalObject* aGlobal) + : DOMEventTargetHelper(aGlobal), + mResourceTimingBufferSize(kDefaultResourceTimingBufferSize), + mPendingNotificationObserversTask(false), + mPendingResourceTimingBufferFullEvent(false), + mRTPCallerType(aGlobal->GetRTPCallerType()), + mCrossOriginIsolated(aGlobal->CrossOriginIsolated()), + mShouldResistFingerprinting(aGlobal->ShouldResistFingerprinting( + RFPTarget::ReduceTimerPrecision)) {} + +Performance::~Performance() = default; + +DOMHighResTimeStamp Performance::TimeStampToDOMHighResForRendering( + TimeStamp aTimeStamp) const { + DOMHighResTimeStamp stamp = GetDOMTiming()->TimeStampToDOMHighRes(aTimeStamp); + // 0 is an inappropriate mixin for this this area; however CSS Animations + // needs to have it's Time Reduction Logic refactored, so it's currently + // only clamping for RFP mode. RFP mode gives a much lower time precision, + // so we accept the security leak here for now. + return nsRFPService::ReduceTimePrecisionAsMSecsRFPOnly(stamp, 0, + mRTPCallerType); +} + +DOMHighResTimeStamp Performance::Now() { + DOMHighResTimeStamp rawTime = NowUnclamped(); + + // XXX: Removing this caused functions in pkcs11f.h to fail. + // Bug 1628021 investigates the root cause - it involves initializing + // the RNG service (part of GetRandomTimelineSeed()) off-main-thread + // but the underlying cause hasn't been identified yet. + if (mRTPCallerType == RTPCallerType::SystemPrincipal) { + return rawTime; + } + + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawTime, GetRandomTimelineSeed(), mRTPCallerType); +} + +DOMHighResTimeStamp Performance::NowUnclamped() const { + TimeDuration duration = TimeStamp::Now() - CreationTimeStamp(); + return duration.ToMilliseconds(); +} + +DOMHighResTimeStamp Performance::TimeOrigin() { + if (!mPerformanceService) { + mPerformanceService = PerformanceService::GetOrCreate(); + } + + MOZ_ASSERT(mPerformanceService); + DOMHighResTimeStamp rawTimeOrigin = + mPerformanceService->TimeOrigin(CreationTimeStamp()); + // Time Origin is an absolute timestamp, so we supply a 0 context mix-in + return nsRFPService::ReduceTimePrecisionAsMSecs(rawTimeOrigin, 0, + mRTPCallerType); +} + +JSObject* Performance::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return Performance_Binding::Wrap(aCx, this, aGivenProto); +} + +void Performance::GetEntries(nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + aRetval = mResourceEntries.Clone(); + aRetval.AppendElements(mUserEntries); + aRetval.Sort(PerformanceEntryComparator()); +} + +void Performance::GetEntriesByType( + const nsAString& aEntryType, nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + if (aEntryType.EqualsLiteral("resource")) { + aRetval = mResourceEntries.Clone(); + return; + } + + aRetval.Clear(); + + if (aEntryType.EqualsLiteral("mark") || aEntryType.EqualsLiteral("measure")) { + RefPtr<nsAtom> entryType = NS_Atomize(aEntryType); + for (PerformanceEntry* entry : mUserEntries) { + if (entry->GetEntryType() == entryType) { + aRetval.AppendElement(entry); + } + } + } +} + +void Performance::GetEntriesByName( + const nsAString& aName, const Optional<nsAString>& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + aRetval.Clear(); + + RefPtr<nsAtom> name = NS_Atomize(aName); + RefPtr<nsAtom> entryType = + aEntryType.WasPassed() ? NS_Atomize(aEntryType.Value()) : nullptr; + + if (entryType) { + if (entryType == nsGkAtoms::mark || entryType == nsGkAtoms::measure) { + for (PerformanceEntry* entry : mUserEntries) { + if (entry->GetName() == name && entry->GetEntryType() == entryType) { + aRetval.AppendElement(entry); + } + } + return; + } + if (entryType == nsGkAtoms::resource) { + for (PerformanceEntry* entry : mResourceEntries) { + MOZ_ASSERT(entry->GetEntryType() == entryType); + if (entry->GetName() == name) { + aRetval.AppendElement(entry); + } + } + return; + } + // Invalid entryType + return; + } + + nsTArray<PerformanceEntry*> qualifiedResourceEntries; + nsTArray<PerformanceEntry*> qualifiedUserEntries; + // ::Measure expects that results from this function are already + // passed through ReduceTimePrecision. mResourceEntries and mUserEntries + // are, so the invariant holds. + for (PerformanceEntry* entry : mResourceEntries) { + if (entry->GetName() == name) { + qualifiedResourceEntries.AppendElement(entry); + } + } + + for (PerformanceEntry* entry : mUserEntries) { + if (entry->GetName() == name) { + qualifiedUserEntries.AppendElement(entry); + } + } + + size_t resourceEntriesIdx = 0, userEntriesIdx = 0; + aRetval.SetCapacity(qualifiedResourceEntries.Length() + + qualifiedUserEntries.Length()); + + PerformanceEntryComparator comparator; + + while (resourceEntriesIdx < qualifiedResourceEntries.Length() && + userEntriesIdx < qualifiedUserEntries.Length()) { + if (comparator.LessThan(qualifiedResourceEntries[resourceEntriesIdx], + qualifiedUserEntries[userEntriesIdx])) { + aRetval.AppendElement(qualifiedResourceEntries[resourceEntriesIdx]); + ++resourceEntriesIdx; + } else { + aRetval.AppendElement(qualifiedUserEntries[userEntriesIdx]); + ++userEntriesIdx; + } + } + + while (resourceEntriesIdx < qualifiedResourceEntries.Length()) { + aRetval.AppendElement(qualifiedResourceEntries[resourceEntriesIdx]); + ++resourceEntriesIdx; + } + + while (userEntriesIdx < qualifiedUserEntries.Length()) { + aRetval.AppendElement(qualifiedUserEntries[userEntriesIdx]); + ++userEntriesIdx; + } +} + +void Performance::GetEntriesByTypeForObserver( + const nsAString& aEntryType, nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + GetEntriesByType(aEntryType, aRetval); +} + +void Performance::ClearUserEntries(const Optional<nsAString>& aEntryName, + const nsAString& aEntryType) { + MOZ_ASSERT(!aEntryType.IsEmpty()); + RefPtr<nsAtom> name = + aEntryName.WasPassed() ? NS_Atomize(aEntryName.Value()) : nullptr; + RefPtr<nsAtom> entryType = NS_Atomize(aEntryType); + mUserEntries.RemoveElementsBy([name, entryType](const auto& entry) { + return (!name || entry->GetName() == name) && + (entry->GetEntryType() == entryType); + }); +} + +void Performance::ClearResourceTimings() { mResourceEntries.Clear(); } + +struct UserTimingMarker : public BaseMarkerType<UserTimingMarker> { + static constexpr const char* Name = "UserTiming"; + static constexpr const char* Description = + "UserTimingMeasure is created using the DOM API performance.measure()."; + + using MS = MarkerSchema; + static constexpr MS::PayloadField PayloadFields[] = { + {"name", MS::InputType::String, "User Marker Name", MS::Format::String, + MS::PayloadFlags::Searchable}, + {"entryType", MS::InputType::Boolean, "Entry Type"}, + {"startMark", MS::InputType::String, "Start Mark"}, + {"endMark", MS::InputType::String, "End Mark"}}; + + static constexpr MS::Location Locations[] = {MS::Location::MarkerChart, + MS::Location::MarkerTable}; + static constexpr const char* AllLabels = "{marker.data.name}"; + + static constexpr MS::ETWMarkerGroup Group = MS::ETWMarkerGroup::UserMarkers; + + static void StreamJSONMarkerData( + baseprofiler::SpliceableJSONWriter& aWriter, + const ProfilerString16View& aName, bool aIsMeasure, + const Maybe<ProfilerString16View>& aStartMark, + const Maybe<ProfilerString16View>& aEndMark) { + StreamJSONMarkerDataImpl( + aWriter, aName, + aIsMeasure ? MakeStringSpan("measure") : MakeStringSpan("mark"), + aStartMark, aEndMark); + } +}; + +already_AddRefed<PerformanceMark> Performance::Mark( + JSContext* aCx, const nsAString& aName, + const PerformanceMarkOptions& aMarkOptions, ErrorResult& aRv) { + nsCOMPtr<nsIGlobalObject> parent = GetParentObject(); + if (!parent || parent->IsDying() || !parent->HasJSGlobal()) { + aRv.ThrowInvalidStateError("Global object is unavailable"); + return nullptr; + } + + GlobalObject global(aCx, parent->GetGlobalJSObject()); + if (global.Failed()) { + aRv.ThrowInvalidStateError("Global object is unavailable"); + return nullptr; + } + + RefPtr<PerformanceMark> performanceMark = + PerformanceMark::Constructor(global, aName, aMarkOptions, aRv); + if (aRv.Failed()) { + return nullptr; + } + + InsertUserEntry(performanceMark); + + if (profiler_is_collecting_markers()) { + Maybe<uint64_t> innerWindowId; + if (GetOwner()) { + innerWindowId = Some(GetOwner()->WindowID()); + } + TimeStamp startTimeStamp = + CreationTimeStamp() + + TimeDuration::FromMilliseconds(performanceMark->UnclampedStartTime()); + profiler_add_marker("UserTiming", geckoprofiler::category::DOM, + MarkerOptions(MarkerTiming::InstantAt(startTimeStamp), + MarkerInnerWindowId(innerWindowId)), + UserTimingMarker{}, aName, /* aIsMeasure */ false, + Nothing{}, Nothing{}); + } + + return performanceMark.forget(); +} + +void Performance::ClearMarks(const Optional<nsAString>& aName) { + ClearUserEntries(aName, u"mark"_ns); +} + +// To be removed once bug 1124165 lands +bool Performance::IsPerformanceTimingAttribute(const nsAString& aName) const { + // Note that toJSON is added to this list due to bug 1047848 + static const char* attributes[] = {"navigationStart", + "unloadEventStart", + "unloadEventEnd", + "redirectStart", + "redirectEnd", + "fetchStart", + "domainLookupStart", + "domainLookupEnd", + "connectStart", + "secureConnectionStart", + "connectEnd", + "requestStart", + "responseStart", + "responseEnd", + "domLoading", + "domInteractive", + "domContentLoadedEventStart", + "domContentLoadedEventEnd", + "domComplete", + "loadEventStart", + "loadEventEnd", + nullptr}; + + for (uint32_t i = 0; attributes[i]; ++i) { + if (aName.EqualsASCII(attributes[i])) { + return true; + } + } + + return false; +} + +DOMHighResTimeStamp Performance::ConvertMarkToTimestampWithString( + const nsAString& aName, ErrorResult& aRv, bool aReturnUnclamped) { + if (IsPerformanceTimingAttribute(aName)) { + return ConvertNameToTimestamp(aName, aRv); + } + + RefPtr<nsAtom> name = NS_Atomize(aName); + // Just loop over the user entries + for (const PerformanceEntry* entry : Reversed(mUserEntries)) { + if (entry->GetName() == name && entry->GetEntryType() == nsGkAtoms::mark) { + if (aReturnUnclamped) { + return entry->UnclampedStartTime(); + } + return entry->StartTime(); + } + } + + nsPrintfCString errorMsg("Given mark name, %s, is unknown", + NS_ConvertUTF16toUTF8(aName).get()); + aRv.ThrowSyntaxError(errorMsg); + return 0; +} + +DOMHighResTimeStamp Performance::ConvertMarkToTimestampWithDOMHighResTimeStamp( + const ResolveTimestampAttribute aAttribute, + const DOMHighResTimeStamp aTimestamp, ErrorResult& aRv) { + if (aTimestamp < 0) { + nsAutoCString attributeName; + switch (aAttribute) { + case ResolveTimestampAttribute::Start: + attributeName = "start"; + break; + case ResolveTimestampAttribute::End: + attributeName = "end"; + break; + case ResolveTimestampAttribute::Duration: + attributeName = "duration"; + break; + } + + nsPrintfCString errorMsg("Given attribute %s cannot be negative", + attributeName.get()); + aRv.ThrowTypeError(errorMsg); + } + return aTimestamp; +} + +DOMHighResTimeStamp Performance::ConvertMarkToTimestamp( + const ResolveTimestampAttribute aAttribute, + const OwningStringOrDouble& aMarkNameOrTimestamp, ErrorResult& aRv, + bool aReturnUnclamped) { + if (aMarkNameOrTimestamp.IsString()) { + return ConvertMarkToTimestampWithString(aMarkNameOrTimestamp.GetAsString(), + aRv, aReturnUnclamped); + } + + return ConvertMarkToTimestampWithDOMHighResTimeStamp( + aAttribute, aMarkNameOrTimestamp.GetAsDouble(), aRv); +} + +DOMHighResTimeStamp Performance::ConvertNameToTimestamp(const nsAString& aName, + ErrorResult& aRv) { + if (!IsGlobalObjectWindow()) { + nsPrintfCString errorMsg( + "Cannot get PerformanceTiming attribute values for non-Window global " + "object. Given: %s", + NS_ConvertUTF16toUTF8(aName).get()); + aRv.ThrowTypeError(errorMsg); + return 0; + } + + if (aName.EqualsASCII("navigationStart")) { + return 0; + } + + // We use GetPerformanceTimingFromString, rather than calling the + // navigationStart method timing function directly, because the former handles + // reducing precision against timing attacks. + const DOMHighResTimeStamp startTime = + GetPerformanceTimingFromString(u"navigationStart"_ns); + const DOMHighResTimeStamp endTime = GetPerformanceTimingFromString(aName); + MOZ_ASSERT(endTime >= 0); + if (endTime == 0) { + nsPrintfCString errorMsg( + "Given PerformanceTiming attribute, %s, isn't available yet", + NS_ConvertUTF16toUTF8(aName).get()); + aRv.ThrowInvalidAccessError(errorMsg); + return 0; + } + + return endTime - startTime; +} + +DOMHighResTimeStamp Performance::ResolveEndTimeForMeasure( + const Optional<nsAString>& aEndMark, + const Maybe<const PerformanceMeasureOptions&>& aOptions, ErrorResult& aRv, + bool aReturnUnclamped) { + DOMHighResTimeStamp endTime; + if (aEndMark.WasPassed()) { + endTime = ConvertMarkToTimestampWithString(aEndMark.Value(), aRv, + aReturnUnclamped); + } else if (aOptions && aOptions->mEnd.WasPassed()) { + endTime = + ConvertMarkToTimestamp(ResolveTimestampAttribute::End, + aOptions->mEnd.Value(), aRv, aReturnUnclamped); + } else if (aOptions && aOptions->mStart.WasPassed() && + aOptions->mDuration.WasPassed()) { + const DOMHighResTimeStamp start = + ConvertMarkToTimestamp(ResolveTimestampAttribute::Start, + aOptions->mStart.Value(), aRv, aReturnUnclamped); + if (aRv.Failed()) { + return 0; + } + + const DOMHighResTimeStamp duration = + ConvertMarkToTimestampWithDOMHighResTimeStamp( + ResolveTimestampAttribute::Duration, aOptions->mDuration.Value(), + aRv); + if (aRv.Failed()) { + return 0; + } + + endTime = start + duration; + } else { + endTime = Now(); + } + + return endTime; +} + +DOMHighResTimeStamp Performance::ResolveStartTimeForMeasure( + const Maybe<const nsAString&>& aStartMark, + const Maybe<const PerformanceMeasureOptions&>& aOptions, ErrorResult& aRv, + bool aReturnUnclamped) { + DOMHighResTimeStamp startTime; + if (aOptions && aOptions->mStart.WasPassed()) { + startTime = + ConvertMarkToTimestamp(ResolveTimestampAttribute::Start, + aOptions->mStart.Value(), aRv, aReturnUnclamped); + } else if (aOptions && aOptions->mDuration.WasPassed() && + aOptions->mEnd.WasPassed()) { + const DOMHighResTimeStamp duration = + ConvertMarkToTimestampWithDOMHighResTimeStamp( + ResolveTimestampAttribute::Duration, aOptions->mDuration.Value(), + aRv); + if (aRv.Failed()) { + return 0; + } + + const DOMHighResTimeStamp end = + ConvertMarkToTimestamp(ResolveTimestampAttribute::End, + aOptions->mEnd.Value(), aRv, aReturnUnclamped); + if (aRv.Failed()) { + return 0; + } + + startTime = end - duration; + } else if (aStartMark) { + startTime = + ConvertMarkToTimestampWithString(*aStartMark, aRv, aReturnUnclamped); + } else { + startTime = 0; + } + + return startTime; +} + +static std::string GetMarkerFilename() { + std::stringstream s; + if (char* markerDir = getenv("MOZ_PERFORMANCE_MARKER_DIR")) { + s << markerDir << "/"; + } +#ifdef XP_WIN + s << "marker-" << GetCurrentProcessId() << ".txt"; +#else + s << "marker-" << getpid() << ".txt"; +#endif + return s.str(); +} + +std::pair<TimeStamp, TimeStamp> Performance::GetTimeStampsForMarker( + const Maybe<const nsAString&>& aStartMark, + const Optional<nsAString>& aEndMark, + const Maybe<const PerformanceMeasureOptions&>& aOptions, ErrorResult& aRv) { + const DOMHighResTimeStamp unclampedStartTime = ResolveStartTimeForMeasure( + aStartMark, aOptions, aRv, /* aReturnUnclamped */ true); + const DOMHighResTimeStamp unclampedEndTime = + ResolveEndTimeForMeasure(aEndMark, aOptions, aRv, /* aReturnUnclamped */ + true); + + TimeStamp startTimeStamp = + CreationTimeStamp() + TimeDuration::FromMilliseconds(unclampedStartTime); + TimeStamp endTimeStamp = + CreationTimeStamp() + TimeDuration::FromMilliseconds(unclampedEndTime); + + return std::make_pair(startTimeStamp, endTimeStamp); +} + +// This emits markers to an external marker-[pid].txt file for use by an +// external profiler like samply or etw-gecko +void Performance::MaybeEmitExternalProfilerMarker( + const nsAString& aName, Maybe<const PerformanceMeasureOptions&> aOptions, + Maybe<const nsAString&> aStartMark, const Optional<nsAString>& aEndMark) { + static FILE* markerFile = getenv("MOZ_USE_PERFORMANCE_MARKER_FILE") + ? fopen(GetMarkerFilename().c_str(), "w+") + : nullptr; + if (!markerFile) { + return; + } + + ErrorResult rv; + auto [startTimeStamp, endTimeStamp] = + GetTimeStampsForMarker(aStartMark, aEndMark, aOptions, rv); + + if (NS_WARN_IF(rv.Failed())) { + return; + } + +#ifdef XP_LINUX + uint64_t rawStart = startTimeStamp.RawClockMonotonicNanosecondsSinceBoot(); + uint64_t rawEnd = endTimeStamp.RawClockMonotonicNanosecondsSinceBoot(); +#elif XP_WIN + uint64_t rawStart = startTimeStamp.RawQueryPerformanceCounterValue().value(); + uint64_t rawEnd = endTimeStamp.RawQueryPerformanceCounterValue().value(); +#elif XP_MACOSX + uint64_t rawStart = startTimeStamp.RawMachAbsoluteTimeNanoseconds(); + uint64_t rawEnd = endTimeStamp.RawMachAbsoluteTimeNanoseconds(); +#else + uint64_t rawStart = 0; + uint64_t rawEnd = 0; + MOZ_CRASH("no timestamp"); +#endif + // Write a line for this measure to the marker file. The marker file uses a + // text-based format where every line is one marker, and each line has the + // format: + // `<raw_start_timestamp> <raw_end_timestamp> <measure_name>` + // + // The timestamp value is OS specific. + fprintf(markerFile, "%" PRIu64 " %" PRIu64 " %s\n", rawStart, rawEnd, + NS_ConvertUTF16toUTF8(aName).get()); + fflush(markerFile); +} + +already_AddRefed<PerformanceMeasure> Performance::Measure( + JSContext* aCx, const nsAString& aName, + const StringOrPerformanceMeasureOptions& aStartOrMeasureOptions, + const Optional<nsAString>& aEndMark, ErrorResult& aRv) { + if (!GetParentObject()) { + aRv.ThrowInvalidStateError("Global object is unavailable"); + return nullptr; + } + + // Maybe is more readable than using the union type directly. + Maybe<const PerformanceMeasureOptions&> options; + if (aStartOrMeasureOptions.IsPerformanceMeasureOptions()) { + options.emplace(aStartOrMeasureOptions.GetAsPerformanceMeasureOptions()); + } + + const bool isOptionsNotEmpty = + options.isSome() && + (!options->mDetail.isUndefined() || options->mStart.WasPassed() || + options->mEnd.WasPassed() || options->mDuration.WasPassed()); + if (isOptionsNotEmpty) { + if (aEndMark.WasPassed()) { + aRv.ThrowTypeError( + "Cannot provide separate endMark argument if " + "PerformanceMeasureOptions argument is given"); + return nullptr; + } + + if (!options->mStart.WasPassed() && !options->mEnd.WasPassed()) { + aRv.ThrowTypeError( + "PerformanceMeasureOptions must have start and/or end member"); + return nullptr; + } + + if (options->mStart.WasPassed() && options->mDuration.WasPassed() && + options->mEnd.WasPassed()) { + aRv.ThrowTypeError( + "PerformanceMeasureOptions cannot have all of the following members: " + "start, duration, and end"); + return nullptr; + } + } + + const DOMHighResTimeStamp endTime = ResolveEndTimeForMeasure( + aEndMark, options, aRv, /* aReturnUnclamped */ false); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + // Convert to Maybe for consistency with options. + Maybe<const nsAString&> startMark; + if (aStartOrMeasureOptions.IsString()) { + startMark.emplace(aStartOrMeasureOptions.GetAsString()); + } + const DOMHighResTimeStamp startTime = ResolveStartTimeForMeasure( + startMark, options, aRv, /* aReturnUnclamped */ false); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + JS::Rooted<JS::Value> detail(aCx); + if (options && !options->mDetail.isNullOrUndefined()) { + StructuredSerializeOptions serializeOptions; + JS::Rooted<JS::Value> valueToClone(aCx, options->mDetail); + nsContentUtils::StructuredClone(aCx, GetParentObject(), valueToClone, + serializeOptions, &detail, aRv); + if (aRv.Failed()) { + return nullptr; + } + } else { + detail.setNull(); + } + + RefPtr<PerformanceMeasure> performanceMeasure = new PerformanceMeasure( + GetParentObject(), aName, startTime, endTime, detail); + InsertUserEntry(performanceMeasure); + + MaybeEmitExternalProfilerMarker(aName, options, startMark, aEndMark); + + if (profiler_is_collecting_markers()) { + auto [startTimeStamp, endTimeStamp] = + GetTimeStampsForMarker(startMark, aEndMark, options, aRv); + + Maybe<nsString> endMark; + if (aEndMark.WasPassed()) { + endMark.emplace(aEndMark.Value()); + } + + Maybe<uint64_t> innerWindowId; + if (GetOwner()) { + innerWindowId = Some(GetOwner()->WindowID()); + } + profiler_add_marker("UserTiming", geckoprofiler::category::DOM, + {MarkerTiming::Interval(startTimeStamp, endTimeStamp), + MarkerInnerWindowId(innerWindowId)}, + UserTimingMarker{}, aName, /* aIsMeasure */ true, + startMark, endMark); + } + + return performanceMeasure.forget(); +} + +void Performance::ClearMeasures(const Optional<nsAString>& aName) { + ClearUserEntries(aName, u"measure"_ns); +} + +void Performance::LogEntry(PerformanceEntry* aEntry, + const nsACString& aOwner) const { + PERFLOG("Performance Entry: %s|%s|%s|%f|%f|%" PRIu64 "\n", + aOwner.BeginReading(), + NS_ConvertUTF16toUTF8(aEntry->GetEntryType()->GetUTF16String()).get(), + NS_ConvertUTF16toUTF8(aEntry->GetName()->GetUTF16String()).get(), + aEntry->StartTime(), aEntry->Duration(), + static_cast<uint64_t>(PR_Now() / PR_USEC_PER_MSEC)); +} + +void Performance::TimingNotification(PerformanceEntry* aEntry, + const nsACString& aOwner, + const double aEpoch) { + PerformanceEntryEventInit init; + init.mBubbles = false; + init.mCancelable = false; + aEntry->GetName(init.mName); + aEntry->GetEntryType(init.mEntryType); + init.mStartTime = aEntry->StartTime(); + init.mDuration = aEntry->Duration(); + init.mEpoch = aEpoch; + CopyUTF8toUTF16(aOwner, init.mOrigin); + + RefPtr<PerformanceEntryEvent> perfEntryEvent = + PerformanceEntryEvent::Constructor(this, u"performanceentry"_ns, init); + + nsCOMPtr<EventTarget> et = do_QueryInterface(GetOwner()); + if (et) { + et->DispatchEvent(*perfEntryEvent); + } +} + +void Performance::InsertUserEntry(PerformanceEntry* aEntry) { + mUserEntries.InsertElementSorted(aEntry, PerformanceEntryComparator()); + + QueueEntry(aEntry); +} + +/* + * Steps are labeled according to the description found at + * https://w3c.github.io/resource-timing/#sec-extensions-performance-interface. + * + * Buffer Full Event + */ +void Performance::BufferEvent() { + /* + * While resource timing secondary buffer is not empty, + * run the following substeps: + */ + while (!mSecondaryResourceEntries.IsEmpty()) { + uint32_t secondaryResourceEntriesBeforeCount = 0; + uint32_t secondaryResourceEntriesAfterCount = 0; + + /* + * Let number of excess entries before be resource + * timing secondary buffer current size. + */ + secondaryResourceEntriesBeforeCount = mSecondaryResourceEntries.Length(); + + /* + * If can add resource timing entry returns false, + * then fire an event named resourcetimingbufferfull + * at the Performance object. + */ + if (!CanAddResourceTimingEntry()) { + DispatchBufferFullEvent(); + } + + /* + * Run copy secondary buffer. + * + * While resource timing secondary buffer is not + * empty and can add resource timing entry returns + * true ... + */ + while (!mSecondaryResourceEntries.IsEmpty() && + CanAddResourceTimingEntry()) { + /* + * Let entry be the oldest PerformanceResourceTiming + * in resource timing secondary buffer. Add entry to + * the end of performance entry buffer. Increment + * resource timing buffer current size by 1. + */ + mResourceEntries.InsertElementSorted( + mSecondaryResourceEntries.ElementAt(0), PerformanceEntryComparator()); + /* + * Remove entry from resource timing secondary buffer. + * Decrement resource timing secondary buffer current + * size by 1. + */ + mSecondaryResourceEntries.RemoveElementAt(0); + } + + /* + * Let number of excess entries after be resource + * timing secondary buffer current size. + */ + secondaryResourceEntriesAfterCount = mSecondaryResourceEntries.Length(); + + /* + * If number of excess entries before is lower than + * or equals number of excess entries after, then + * remove all entries from resource timing secondary + * buffer, set resource timing secondary buffer current + * size to 0, and abort these steps. + */ + if (secondaryResourceEntriesBeforeCount <= + secondaryResourceEntriesAfterCount) { + mSecondaryResourceEntries.Clear(); + break; + } + } + /* + * Set resource timing buffer full event pending flag + * to false. + */ + mPendingResourceTimingBufferFullEvent = false; +} + +void Performance::SetResourceTimingBufferSize(uint64_t aMaxSize) { + mResourceTimingBufferSize = aMaxSize; +} + +/* + * Steps are labeled according to the description found at + * https://w3c.github.io/resource-timing/#sec-extensions-performance-interface. + * + * Can Add Resource Timing Entry + */ +MOZ_ALWAYS_INLINE bool Performance::CanAddResourceTimingEntry() { + /* + * If resource timing buffer current size is smaller than resource timing + * buffer size limit, return true. [Otherwise,] [r]eturn false. + */ + return mResourceEntries.Length() < mResourceTimingBufferSize; +} + +/* + * Steps are labeled according to the description found at + * https://w3c.github.io/resource-timing/#sec-extensions-performance-interface. + * + * Add a PerformanceResourceTiming Entry + */ +void Performance::InsertResourceEntry(PerformanceEntry* aEntry) { + MOZ_ASSERT(aEntry); + + QueueEntry(aEntry); + + /* + * Let new entry be the input PerformanceEntry to be added. + * + * If can add resource timing entry returns true and resource + * timing buffer full event pending flag is false ... + */ + if (CanAddResourceTimingEntry() && !mPendingResourceTimingBufferFullEvent) { + /* + * Add new entry to the performance entry buffer. + * Increase resource timing buffer current size by 1. + */ + mResourceEntries.InsertElementSorted(aEntry, PerformanceEntryComparator()); + return; + } + + /* + * If resource timing buffer full event pending flag is + * false ... + */ + if (!mPendingResourceTimingBufferFullEvent) { + /* + * Set resource timing buffer full event pending flag + * to true. + */ + mPendingResourceTimingBufferFullEvent = true; + + /* + * Queue a task to run fire a buffer full event. + */ + NS_DispatchToCurrentThread(NewCancelableRunnableMethod( + "Performance::BufferEvent", this, &Performance::BufferEvent)); + } + /* + * Add new entry to the resource timing secondary buffer. + * Increase resource timing secondary buffer current size + * by 1. + */ + mSecondaryResourceEntries.InsertElementSorted(aEntry, + PerformanceEntryComparator()); +} + +void Performance::AddObserver(PerformanceObserver* aObserver) { + mObservers.AppendElementUnlessExists(aObserver); +} + +void Performance::RemoveObserver(PerformanceObserver* aObserver) { + mObservers.RemoveElement(aObserver); +} + +void Performance::NotifyObservers() { + mPendingNotificationObserversTask = false; + NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(mObservers, Notify, ()); +} + +void Performance::CancelNotificationObservers() { + mPendingNotificationObserversTask = false; +} + +class NotifyObserversTask final : public CancelableRunnable { + public: + explicit NotifyObserversTask(Performance* aPerformance) + : CancelableRunnable("dom::NotifyObserversTask"), + mPerformance(aPerformance) { + MOZ_ASSERT(mPerformance); + } + + // MOZ_CAN_RUN_SCRIPT_BOUNDARY for now until Runnable::Run is + // MOZ_CAN_RUN_SCRIPT. + MOZ_CAN_RUN_SCRIPT_BOUNDARY + NS_IMETHOD Run() override { + MOZ_ASSERT(mPerformance); + RefPtr<Performance> performance(mPerformance); + performance->NotifyObservers(); + return NS_OK; + } + + nsresult Cancel() override { + mPerformance->CancelNotificationObservers(); + mPerformance = nullptr; + return NS_OK; + } + + private: + ~NotifyObserversTask() = default; + + RefPtr<Performance> mPerformance; +}; + +void Performance::QueueNotificationObserversTask() { + if (!mPendingNotificationObserversTask) { + RunNotificationObserversTask(); + } +} + +void Performance::RunNotificationObserversTask() { + mPendingNotificationObserversTask = true; + nsCOMPtr<nsIRunnable> task = new NotifyObserversTask(this); + nsresult rv; + if (nsIGlobalObject* global = GetOwnerGlobal()) { + rv = global->Dispatch(task.forget()); + } else { + rv = NS_DispatchToCurrentThread(task.forget()); + } + if (NS_WARN_IF(NS_FAILED(rv))) { + mPendingNotificationObserversTask = false; + } +} + +void Performance::QueueEntry(PerformanceEntry* aEntry) { + nsTObserverArray<PerformanceObserver*> interestedObservers; + if (!mObservers.IsEmpty()) { + const auto [begin, end] = mObservers.NonObservingRange(); + std::copy_if(begin, end, MakeBackInserter(interestedObservers), + [aEntry](PerformanceObserver* observer) { + return observer->ObservesTypeOfEntry(aEntry); + }); + } + + NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(interestedObservers, QueueEntry, + (aEntry)); + + aEntry->BufferEntryIfNeeded(); + + if (!interestedObservers.IsEmpty()) { + QueueNotificationObserversTask(); + } +} + +// We could clear User entries here, but doing so could break sites that call +// performance.measure() if the marks disappeared without warning. Chrome +// allows "infinite" entries. +void Performance::MemoryPressure() {} + +size_t Performance::SizeOfUserEntries( + mozilla::MallocSizeOf aMallocSizeOf) const { + size_t userEntries = 0; + for (const PerformanceEntry* entry : mUserEntries) { + userEntries += entry->SizeOfIncludingThis(aMallocSizeOf); + } + return userEntries; +} + +size_t Performance::SizeOfResourceEntries( + mozilla::MallocSizeOf aMallocSizeOf) const { + size_t resourceEntries = 0; + for (const PerformanceEntry* entry : mResourceEntries) { + resourceEntries += entry->SizeOfIncludingThis(aMallocSizeOf); + } + return resourceEntries; +} + +} // namespace mozilla::dom diff --git a/dom/performance/Performance.h b/dom/performance/Performance.h new file mode 100644 index 0000000000..982b5c04ec --- /dev/null +++ b/dom/performance/Performance.h @@ -0,0 +1,259 @@ +/* -*- 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_Performance_h +#define mozilla_dom_Performance_h + +#include "mozilla/Attributes.h" +#include "mozilla/DOMEventTargetHelper.h" +#include "nsCOMPtr.h" +#include "nsContentUtils.h" +#include "nsDOMNavigationTiming.h" +#include "nsTObserverArray.h" + +class nsITimedChannel; + +namespace mozilla { + +class ErrorResult; + +namespace dom { + +class OwningStringOrDouble; +class StringOrPerformanceMeasureOptions; +class PerformanceEntry; +class PerformanceMark; +struct PerformanceMarkOptions; +struct PerformanceMeasureOptions; +class PerformanceMeasure; +class PerformanceNavigation; +class PerformancePaintTiming; +class PerformanceObserver; +class PerformanceService; +class PerformanceStorage; +class PerformanceTiming; +class PerformanceEventTiming; +class WorkerGlobalScope; +class EventCounts; + +// Base class for main-thread and worker Performance API +class Performance : public DOMEventTargetHelper { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(Performance, DOMEventTargetHelper) + + static bool IsObserverEnabled(JSContext* aCx, JSObject* aGlobal); + + static already_AddRefed<Performance> CreateForMainThread( + nsPIDOMWindowInner* aWindow, nsIPrincipal* aPrincipal, + nsDOMNavigationTiming* aDOMTiming, nsITimedChannel* aChannel); + + static already_AddRefed<Performance> CreateForWorker( + WorkerGlobalScope* aGlobalScope); + + // This will return nullptr if called outside of a Window or Worker. + static already_AddRefed<Performance> Get(JSContext* aCx, + nsIGlobalObject* aGlobal); + + JSObject* WrapObject(JSContext* cx, + JS::Handle<JSObject*> aGivenProto) override; + + virtual void GetEntries(nsTArray<RefPtr<PerformanceEntry>>& aRetval); + + virtual void GetEntriesByType(const nsAString& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& aRetval); + + virtual void GetEntriesByTypeForObserver( + const nsAString& aEntryType, nsTArray<RefPtr<PerformanceEntry>>& aRetval); + + virtual void GetEntriesByName(const nsAString& aName, + const Optional<nsAString>& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& aRetval); + + virtual PerformanceStorage* AsPerformanceStorage() = 0; + + void ClearResourceTimings(); + + DOMHighResTimeStamp Now(); + + DOMHighResTimeStamp NowUnclamped() const; + + DOMHighResTimeStamp TimeOrigin(); + + already_AddRefed<PerformanceMark> Mark( + JSContext* aCx, const nsAString& aName, + const PerformanceMarkOptions& aMarkOptions, ErrorResult& aRv); + + void ClearMarks(const Optional<nsAString>& aName); + + already_AddRefed<PerformanceMeasure> Measure( + JSContext* aCx, const nsAString& aName, + const StringOrPerformanceMeasureOptions& aStartOrMeasureOptions, + const Optional<nsAString>& aEndMark, ErrorResult& aRv); + + void ClearMeasures(const Optional<nsAString>& aName); + + void SetResourceTimingBufferSize(uint64_t aMaxSize); + + void AddObserver(PerformanceObserver* aObserver); + void RemoveObserver(PerformanceObserver* aObserver); + MOZ_CAN_RUN_SCRIPT void NotifyObservers(); + void CancelNotificationObservers(); + + virtual PerformanceTiming* Timing() = 0; + + virtual PerformanceNavigation* Navigation() = 0; + + virtual void SetFCPTimingEntry(PerformancePaintTiming* aEntry) = 0; + + IMPL_EVENT_HANDLER(resourcetimingbufferfull) + + virtual void GetMozMemory(JSContext* aCx, + JS::MutableHandle<JSObject*> aObj) = 0; + + virtual nsDOMNavigationTiming* GetDOMTiming() const = 0; + + virtual nsITimedChannel* GetChannel() const = 0; + + virtual TimeStamp CreationTimeStamp() const = 0; + + RTPCallerType GetRTPCallerType() const { return mRTPCallerType; } + + bool CrossOriginIsolated() const { return mCrossOriginIsolated; } + bool ShouldResistFingerprinting() const { + return mShouldResistFingerprinting; + } + + DOMHighResTimeStamp TimeStampToDOMHighResForRendering(TimeStamp) const; + + virtual uint64_t GetRandomTimelineSeed() = 0; + + void MemoryPressure(); + + size_t SizeOfUserEntries(mozilla::MallocSizeOf aMallocSizeOf) const; + size_t SizeOfResourceEntries(mozilla::MallocSizeOf aMallocSizeOf) const; + virtual size_t SizeOfEventEntries(mozilla::MallocSizeOf aMallocSizeOf) const { + return 0; + } + + void InsertResourceEntry(PerformanceEntry* aEntry); + + virtual void InsertEventTimingEntry(PerformanceEventTiming* aEntry) = 0; + + virtual void BufferEventTimingEntryIfNeeded( + PerformanceEventTiming* aEntry) = 0; + + virtual class EventCounts* EventCounts() = 0; + + virtual void QueueNavigationTimingEntry() = 0; + + virtual void UpdateNavigationTimingEntry() = 0; + + virtual void DispatchPendingEventTimingEntries() = 0; + + void QueueNotificationObserversTask(); + + bool IsPerformanceTimingAttribute(const nsAString& aName) const; + + virtual bool IsGlobalObjectWindow() const { return false; }; + + protected: + Performance(nsIGlobalObject* aGlobal); + Performance(nsPIDOMWindowInner* aWindow); + + virtual ~Performance(); + + virtual void InsertUserEntry(PerformanceEntry* aEntry); + + void ClearUserEntries(const Optional<nsAString>& aEntryName, + const nsAString& aEntryType); + + virtual void DispatchBufferFullEvent() = 0; + + virtual DOMHighResTimeStamp CreationTime() const = 0; + + virtual DOMHighResTimeStamp GetPerformanceTimingFromString( + const nsAString& aTimingName) { + return 0; + } + + void LogEntry(PerformanceEntry* aEntry, const nsACString& aOwner) const; + void TimingNotification(PerformanceEntry* aEntry, const nsACString& aOwner, + const double aEpoch); + + void RunNotificationObserversTask(); + void QueueEntry(PerformanceEntry* aEntry); + + nsTObserverArray<RefPtr<PerformanceObserver>> mObservers; + + protected: + static const uint64_t kDefaultResourceTimingBufferSize = 250; + + // When kDefaultResourceTimingBufferSize is increased or removed, these should + // be changed to use SegmentedVector + AutoTArray<RefPtr<PerformanceEntry>, kDefaultResourceTimingBufferSize> + mUserEntries; + AutoTArray<RefPtr<PerformanceEntry>, kDefaultResourceTimingBufferSize> + mResourceEntries; + AutoTArray<RefPtr<PerformanceEntry>, kDefaultResourceTimingBufferSize> + mSecondaryResourceEntries; + + uint64_t mResourceTimingBufferSize; + bool mPendingNotificationObserversTask; + + bool mPendingResourceTimingBufferFullEvent; + + RefPtr<PerformanceService> mPerformanceService; + + const RTPCallerType mRTPCallerType; + const bool mCrossOriginIsolated; + const bool mShouldResistFingerprinting; + + private: + MOZ_ALWAYS_INLINE bool CanAddResourceTimingEntry(); + void BufferEvent(); + void MaybeEmitExternalProfilerMarker( + const nsAString& aName, Maybe<const PerformanceMeasureOptions&> aOptions, + Maybe<const nsAString&> aStartMark, const Optional<nsAString>& aEndMark); + + // The attributes of a PerformanceMeasureOptions that we call + // ResolveTimestamp* on. + enum class ResolveTimestampAttribute; + + DOMHighResTimeStamp ConvertMarkToTimestampWithString(const nsAString& aName, + ErrorResult& aRv, + bool aReturnUnclamped); + DOMHighResTimeStamp ConvertMarkToTimestampWithDOMHighResTimeStamp( + const ResolveTimestampAttribute aAttribute, const double aTimestamp, + ErrorResult& aRv); + DOMHighResTimeStamp ConvertMarkToTimestamp( + const ResolveTimestampAttribute aAttribute, + const OwningStringOrDouble& aMarkNameOrTimestamp, ErrorResult& aRv, + bool aReturnUnclamped); + + DOMHighResTimeStamp ConvertNameToTimestamp(const nsAString& aName, + ErrorResult& aRv); + + DOMHighResTimeStamp ResolveEndTimeForMeasure( + const Optional<nsAString>& aEndMark, + const Maybe<const PerformanceMeasureOptions&>& aOptions, ErrorResult& aRv, + bool aReturnUnclamped); + DOMHighResTimeStamp ResolveStartTimeForMeasure( + const Maybe<const nsAString&>& aStartMark, + const Maybe<const PerformanceMeasureOptions&>& aOptions, ErrorResult& aRv, + bool aReturnUnclamped); + + std::pair<TimeStamp, TimeStamp> GetTimeStampsForMarker( + const Maybe<const nsAString&>& aStartMark, + const Optional<nsAString>& aEndMark, + const Maybe<const PerformanceMeasureOptions&>& aOptions, + ErrorResult& aRv); +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_Performance_h diff --git a/dom/performance/PerformanceEntry.cpp b/dom/performance/PerformanceEntry.cpp new file mode 100644 index 0000000000..f9337cc1ce --- /dev/null +++ b/dom/performance/PerformanceEntry.cpp @@ -0,0 +1,54 @@ +/* -*- 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 "PerformanceEntry.h" +#include "MainThreadUtils.h" + +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PerformanceEntry, mParent) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(PerformanceEntry) +NS_IMPL_CYCLE_COLLECTING_RELEASE(PerformanceEntry) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceEntry) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +PerformanceEntry::PerformanceEntry(nsISupports* aParent, const nsAString& aName, + const nsAString& aEntryType) + : mParent(aParent), + mName(NS_Atomize(aName)), + mEntryType(NS_Atomize(aEntryType)) {} + +PerformanceEntry::~PerformanceEntry() = default; + +size_t PerformanceEntry::SizeOfExcludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const { + // mName and mEntryType are considered to be owned by nsAtomTable. + return 0; +} + +size_t PerformanceEntry::SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} + +bool PerformanceEntry::ShouldAddEntryToObserverBuffer( + PerformanceObserverInit& aOption) const { + if (aOption.mType.WasPassed()) { + if (GetEntryType()->Equals(aOption.mType.Value())) { + return true; + } + } else { + if (aOption.mEntryTypes.Value().Contains( + nsDependentAtomString(GetEntryType()))) { + return true; + } + } + return false; +} diff --git a/dom/performance/PerformanceEntry.h b/dom/performance/PerformanceEntry.h new file mode 100644 index 0000000000..37a13105f9 --- /dev/null +++ b/dom/performance/PerformanceEntry.h @@ -0,0 +1,104 @@ +/* -*- 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_PerformanceEntry_h___ +#define mozilla_dom_PerformanceEntry_h___ + +#include "nsDOMNavigationTiming.h" +#include "nsString.h" +#include "nsWrapperCache.h" +#include "nsAtom.h" +#include "mozilla/dom/PerformanceObserverBinding.h" + +class nsISupports; + +namespace mozilla::dom { +class PerformanceResourceTiming; + +// http://www.w3.org/TR/performance-timeline/#performanceentry +class PerformanceEntry : public nsISupports, public nsWrapperCache { + protected: + virtual ~PerformanceEntry(); + + public: + PerformanceEntry(nsISupports* aParent, const nsAString& aName, + const nsAString& aEntryType); + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PerformanceEntry) + + nsISupports* GetParentObject() const { return mParent; } + + void GetName(nsAString& aName) const { + if (mName) { + mName->ToString(aName); + } + } + + const nsAtom* GetName() const { return mName; } + + void GetEntryType(nsAString& aEntryType) const { + if (mEntryType) { + mEntryType->ToString(aEntryType); + } + } + + const nsAtom* GetEntryType() const { return mEntryType; } + + void SetEntryType(const nsAString& aEntryType) { + mEntryType = NS_Atomize(aEntryType); + } + + virtual DOMHighResTimeStamp StartTime() const { return 0; } + + // This is used by the Gecko Profiler only for adding precise markers. + // It's not exposed to JS. + virtual DOMHighResTimeStamp UnclampedStartTime() const { + MOZ_ASSERT(false, "UnclampedStartTime should not be called on this class."); + return 0; + } + + virtual DOMHighResTimeStamp Duration() const { return 0; } + + virtual const PerformanceResourceTiming* ToResourceTiming() const { + return nullptr; + } + + virtual bool ShouldAddEntryToObserverBuffer( + PerformanceObserverInit& aOption) const; + + virtual void BufferEntryIfNeeded() {} + + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; + + protected: + virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; + + private: + nsCOMPtr<nsISupports> mParent; + RefPtr<nsAtom> mName; + RefPtr<nsAtom> mEntryType; +}; + +// Helper classes +class MOZ_STACK_CLASS PerformanceEntryComparator final { + public: + bool Equals(const PerformanceEntry* aElem1, + const PerformanceEntry* aElem2) const { + MOZ_ASSERT(aElem1 && aElem2, "Trying to compare null performance entries"); + return aElem1->StartTime() == aElem2->StartTime(); + } + + bool LessThan(const PerformanceEntry* aElem1, + const PerformanceEntry* aElem2) const { + MOZ_ASSERT(aElem1 && aElem2, "Trying to compare null performance entries"); + return aElem1->StartTime() < aElem2->StartTime(); + } +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_PerformanceEntry_h___ */ diff --git a/dom/performance/PerformanceEventTiming.cpp b/dom/performance/PerformanceEventTiming.cpp new file mode 100644 index 0000000000..7a89329362 --- /dev/null +++ b/dom/performance/PerformanceEventTiming.cpp @@ -0,0 +1,207 @@ +/* -*- 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 "PerformanceEventTiming.h" +#include "PerformanceMainThread.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/dom/PerformanceEventTimingBinding.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/Event.h" +#include "nsContentUtils.h" +#include "nsIDocShell.h" +#include <algorithm> + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_INHERITED(PerformanceEventTiming, PerformanceEntry, + mPerformance, mTarget) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceEventTiming) +NS_INTERFACE_MAP_END_INHERITING(PerformanceEntry) + +NS_IMPL_ADDREF_INHERITED(PerformanceEventTiming, PerformanceEntry) +NS_IMPL_RELEASE_INHERITED(PerformanceEventTiming, PerformanceEntry) + +PerformanceEventTiming::PerformanceEventTiming(Performance* aPerformance, + const nsAString& aName, + const TimeStamp& aStartTime, + bool aIsCacelable, + EventMessage aMessage) + : PerformanceEntry(aPerformance->GetParentObject(), aName, u"event"_ns), + mPerformance(aPerformance), + mProcessingStart(aPerformance->NowUnclamped()), + mProcessingEnd(0), + mStartTime( + aPerformance->GetDOMTiming()->TimeStampToDOMHighRes(aStartTime)), + mDuration(0), + mCancelable(aIsCacelable), + mMessage(aMessage) {} + +PerformanceEventTiming::PerformanceEventTiming( + const PerformanceEventTiming& aEventTimingEntry) + : PerformanceEntry(aEventTimingEntry.mPerformance->GetParentObject(), + nsDependentAtomString(aEventTimingEntry.GetName()), + nsDependentAtomString(aEventTimingEntry.GetEntryType())), + mPerformance(aEventTimingEntry.mPerformance), + mProcessingStart(aEventTimingEntry.mProcessingStart), + mProcessingEnd(aEventTimingEntry.mProcessingEnd), + mTarget(aEventTimingEntry.mTarget), + mStartTime(aEventTimingEntry.mStartTime), + mDuration(aEventTimingEntry.mDuration), + mCancelable(aEventTimingEntry.mCancelable), + mMessage(aEventTimingEntry.mMessage) {} + +JSObject* PerformanceEventTiming::WrapObject( + JSContext* cx, JS::Handle<JSObject*> aGivenProto) { + return PerformanceEventTiming_Binding::Wrap(cx, this, aGivenProto); +} + +already_AddRefed<PerformanceEventTiming> +PerformanceEventTiming::TryGenerateEventTiming(const EventTarget* aTarget, + const WidgetEvent* aEvent) { + MOZ_ASSERT(NS_IsMainThread()); + if (!StaticPrefs::dom_enable_event_timing() || + aEvent->mFlags.mOnlyChromeDispatch) { + return nullptr; + } + + if (!aEvent->IsTrusted()) { + return nullptr; + } + + switch (aEvent->mMessage) { + case eMouseAuxClick: + case eMouseClick: + case eContextMenu: + case eMouseDoubleClick: + case eMouseDown: + case eMouseEnter: + case eMouseLeave: + case eMouseOut: + case eMouseOver: + case eMouseUp: + case ePointerOver: + case ePointerEnter: + case ePointerDown: + case ePointerUp: + case ePointerCancel: + case ePointerOut: + case ePointerLeave: + case ePointerGotCapture: + case ePointerLostCapture: + case eTouchStart: + case eTouchEnd: + case eTouchCancel: + case eKeyDown: + case eKeyPress: + case eKeyUp: + case eEditorBeforeInput: + case eEditorInput: + case eCompositionStart: + case eCompositionUpdate: + case eCompositionEnd: + case eDragStart: + case eDragEnd: + case eDragEnter: + case eDragLeave: + case eDragOver: + case eDrop: + break; + default: + return nullptr; + } + + nsCOMPtr<nsPIDOMWindowInner> innerWindow = + do_QueryInterface(aTarget->GetOwnerGlobal()); + if (!innerWindow) { + return nullptr; + } + + if (Performance* performance = innerWindow->GetPerformance()) { + const char16_t* eventName = Event::GetEventName(aEvent->mMessage); + MOZ_ASSERT(eventName, + "User defined events shouldn't be considered as event timing"); + return RefPtr<PerformanceEventTiming>( + new PerformanceEventTiming( + performance, nsDependentString(eventName), + aEvent->mTimeStamp, aEvent->mFlags.mCancelable, + aEvent->mMessage)) + .forget(); + } + return nullptr; +} + +bool PerformanceEventTiming::ShouldAddEntryToBuffer(double aDuration) const { + if (GetEntryType() == nsGkAtoms::firstInput) { + return true; + } + MOZ_ASSERT(GetEntryType() == nsGkAtoms::event); + return RawDuration() >= aDuration; +} + +bool PerformanceEventTiming::ShouldAddEntryToObserverBuffer( + PerformanceObserverInit& aOption) const { + if (!PerformanceEntry::ShouldAddEntryToObserverBuffer(aOption)) { + return false; + } + + const double minDuration = + aOption.mDurationThreshold.WasPassed() + ? std::max(aOption.mDurationThreshold.Value(), + PerformanceMainThread::kDefaultEventTimingMinDuration) + : PerformanceMainThread::kDefaultEventTimingDurationThreshold; + + return ShouldAddEntryToBuffer(minDuration); +} + +void PerformanceEventTiming::BufferEntryIfNeeded() { + if (ShouldAddEntryToBuffer( + PerformanceMainThread::kDefaultEventTimingDurationThreshold)) { + if (GetEntryType() != nsGkAtoms::firstInput) { + MOZ_ASSERT(GetEntryType() == nsGkAtoms::event); + mPerformance->BufferEventTimingEntryIfNeeded(this); + } + } +} + +nsINode* PerformanceEventTiming::GetTarget() const { + nsCOMPtr<Element> element = do_QueryReferent(mTarget); + if (!element) { + return nullptr; + } + + nsCOMPtr<nsPIDOMWindowInner> global = + do_QueryInterface(element->GetOwnerGlobal()); + if (!global) { + return nullptr; + } + return nsContentUtils::GetAnElementForTiming(element, global->GetExtantDoc(), + mPerformance->GetParentObject()); +} + +void PerformanceEventTiming::FinalizeEventTiming(EventTarget* aTarget) { + if (!aTarget) { + return; + } + nsCOMPtr<nsPIDOMWindowInner> global = + do_QueryInterface(aTarget->GetOwnerGlobal()); + if (!global) { + return; + } + + mProcessingEnd = mPerformance->NowUnclamped(); + + Element* element = Element::FromEventTarget(aTarget); + if (!element || element->ChromeOnlyAccess()) { + return; + } + + mTarget = do_GetWeakReference(element); + + mPerformance->InsertEventTimingEntry(this); +} +} // namespace mozilla::dom diff --git a/dom/performance/PerformanceEventTiming.h b/dom/performance/PerformanceEventTiming.h new file mode 100644 index 0000000000..3f39610d95 --- /dev/null +++ b/dom/performance/PerformanceEventTiming.h @@ -0,0 +1,136 @@ +/* -*- 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_PerformanceEventTiming_h___ +#define mozilla_dom_PerformanceEventTiming_h___ + +#include "mozilla/dom/PerformanceEntry.h" +#include "mozilla/EventForwards.h" +#include "nsRFPService.h" +#include "Performance.h" +#include "nsIWeakReferenceUtils.h" +#include "nsINode.h" + +namespace mozilla { +class WidgetEvent; +namespace dom { + +class PerformanceEventTiming final + : public PerformanceEntry, + public LinkedListElement<RefPtr<PerformanceEventTiming>> { + public: + NS_DECL_ISUPPORTS_INHERITED + + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PerformanceEventTiming, + PerformanceEntry) + + static already_AddRefed<PerformanceEventTiming> TryGenerateEventTiming( + const EventTarget* aTarget, const WidgetEvent* aEvent); + + already_AddRefed<PerformanceEventTiming> Clone() { + RefPtr<PerformanceEventTiming> eventTiming = + new PerformanceEventTiming(*this); + return eventTiming.forget(); + } + + JSObject* WrapObject(JSContext* cx, + JS::Handle<JSObject*> aGivenProto) override; + + DOMHighResTimeStamp ProcessingStart() const { + if (mCachedProcessingStart.isNothing()) { + mCachedProcessingStart.emplace(nsRFPService::ReduceTimePrecisionAsMSecs( + mProcessingStart, mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType())); + } + return mCachedProcessingStart.value(); + } + + DOMHighResTimeStamp ProcessingEnd() const { + if (mCachedProcessingEnd.isNothing()) { + mCachedProcessingEnd.emplace(nsRFPService::ReduceTimePrecisionAsMSecs( + mProcessingEnd, mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType())); + } + return mCachedProcessingEnd.value(); + } + + bool Cancelable() const { return mCancelable; } + + nsINode* GetTarget() const; + + void SetDuration(const DOMHighResTimeStamp aDuration) { + mDuration = aDuration; + } + + // nsRFPService::ReduceTimePrecisionAsMSecs might causes + // some memory overhead, using the raw timestamp internally + // to avoid calling in unnecessarily. + DOMHighResTimeStamp RawDuration() const { return mDuration; } + + DOMHighResTimeStamp Duration() const override { + if (mCachedDuration.isNothing()) { + mCachedDuration.emplace(nsRFPService::ReduceTimePrecisionAsMSecs( + mDuration, mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType())); + } + return mCachedDuration.value(); + } + + // Similar as RawDuration; Used to avoid calling + // nsRFPService::ReduceTimePrecisionAsMSecs unnecessarily. + DOMHighResTimeStamp RawStartTime() const { return mStartTime; } + + DOMHighResTimeStamp StartTime() const override { + if (mCachedStartTime.isNothing()) { + mCachedStartTime.emplace(nsRFPService::ReduceTimePrecisionAsMSecs( + mStartTime, mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType())); + } + return mCachedStartTime.value(); + } + + bool ShouldAddEntryToBuffer(double aDuration) const; + bool ShouldAddEntryToObserverBuffer(PerformanceObserverInit&) const override; + + void BufferEntryIfNeeded() override; + + void FinalizeEventTiming(EventTarget* aTarget); + + EventMessage GetMessage() const { return mMessage; } + + private: + PerformanceEventTiming(Performance* aPerformance, const nsAString& aName, + const TimeStamp& aStartTime, bool aIsCacelable, + EventMessage aMessage); + + PerformanceEventTiming(const PerformanceEventTiming& aEventTimingEntry); + + ~PerformanceEventTiming() = default; + + RefPtr<Performance> mPerformance; + + DOMHighResTimeStamp mProcessingStart; + mutable Maybe<DOMHighResTimeStamp> mCachedProcessingStart; + + DOMHighResTimeStamp mProcessingEnd; + mutable Maybe<DOMHighResTimeStamp> mCachedProcessingEnd; + + nsWeakPtr mTarget; + + DOMHighResTimeStamp mStartTime; + mutable Maybe<DOMHighResTimeStamp> mCachedStartTime; + + DOMHighResTimeStamp mDuration; + mutable Maybe<DOMHighResTimeStamp> mCachedDuration; + + bool mCancelable; + + EventMessage mMessage; +}; +} // namespace dom +} // namespace mozilla + +#endif diff --git a/dom/performance/PerformanceMainThread.cpp b/dom/performance/PerformanceMainThread.cpp new file mode 100644 index 0000000000..324f944d50 --- /dev/null +++ b/dom/performance/PerformanceMainThread.cpp @@ -0,0 +1,756 @@ +/* -*- 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 "PerformanceMainThread.h" +#include "PerformanceNavigation.h" +#include "PerformancePaintTiming.h" +#include "jsapi.h" +#include "js/GCAPI.h" +#include "js/PropertyAndElement.h" // JS_DefineProperty +#include "mozilla/HoldDropJSObjects.h" +#include "PerformanceEventTiming.h" +#include "LargestContentfulPaint.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/EventCounts.h" +#include "mozilla/dom/PerformanceEventTimingBinding.h" +#include "mozilla/dom/PerformanceNavigationTiming.h" +#include "mozilla/dom/PerformanceResourceTiming.h" +#include "mozilla/dom/PerformanceTiming.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/StaticPrefs_privacy.h" +#include "mozilla/PresShell.h" +#include "nsIChannel.h" +#include "nsIHttpChannel.h" +#include "nsIDocShell.h" +#include "nsTextFrame.h" +#include "nsContainerFrame.h" + +namespace mozilla::dom { + +extern mozilla::LazyLogModule gLCPLogging; + +namespace { + +void GetURLSpecFromChannel(nsITimedChannel* aChannel, nsAString& aSpec) { + aSpec.AssignLiteral("document"); + + nsCOMPtr<nsIChannel> channel = do_QueryInterface(aChannel); + if (!channel) { + return; + } + + nsCOMPtr<nsIURI> uri; + nsresult rv = channel->GetURI(getter_AddRefs(uri)); + if (NS_WARN_IF(NS_FAILED(rv)) || !uri) { + return; + } + + nsAutoCString spec; + rv = uri->GetSpec(spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + CopyUTF8toUTF16(spec, aSpec); +} + +} // namespace + +NS_IMPL_CYCLE_COLLECTION_CLASS(PerformanceMainThread) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(PerformanceMainThread, + Performance) + NS_IMPL_CYCLE_COLLECTION_UNLINK( + mTiming, mNavigation, mDocEntry, mFCPTiming, mEventTimingEntries, + mLargestContentfulPaintEntries, mFirstInputEvent, mPendingPointerDown, + mPendingEventTimingEntries, mEventCounts) + tmp->mImageLCPEntryMap.Clear(); + tmp->mTextFrameUnions.Clear(); + mozilla::DropJSObjects(tmp); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(PerformanceMainThread, + Performance) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE( + mTiming, mNavigation, mDocEntry, mFCPTiming, mEventTimingEntries, + mLargestContentfulPaintEntries, mFirstInputEvent, mPendingPointerDown, + mPendingEventTimingEntries, mEventCounts, mImageLCPEntryMap, + mTextFrameUnions) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(PerformanceMainThread, + Performance) + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mMozMemory) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_ADDREF_INHERITED(PerformanceMainThread, Performance) +NS_IMPL_RELEASE_INHERITED(PerformanceMainThread, Performance) + +// QueryInterface implementation for PerformanceMainThread +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceMainThread) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, EventTarget) +NS_INTERFACE_MAP_END_INHERITING(Performance) + +PerformanceMainThread::PerformanceMainThread(nsPIDOMWindowInner* aWindow, + nsDOMNavigationTiming* aDOMTiming, + nsITimedChannel* aChannel) + : Performance(aWindow->AsGlobal()), + mDOMTiming(aDOMTiming), + mChannel(aChannel) { + MOZ_ASSERT(aWindow, "Parent window object should be provided"); + if (StaticPrefs::dom_enable_event_timing()) { + mEventCounts = new class EventCounts(GetParentObject()); + } + CreateNavigationTimingEntry(); + + if (StaticPrefs::dom_enable_largest_contentful_paint()) { + nsCOMPtr<nsPIDOMWindowInner> owner = GetOwner(); + MarkerInnerWindowId innerWindowID = + owner ? MarkerInnerWindowId(owner->WindowID()) + : MarkerInnerWindowId::NoId(); + // There might be multiple LCP entries and we only care about the latest one + // which is also the biggest value. That's why we need to record these + // markers in two different places: + // - During the Document unload, so we can record the closed pages. + // - During the profile capture, so we can record the open pages. + // We are capturing the second one here. + // Our static analysis doesn't allow capturing ref-counted pointers in + // lambdas, so we need to hide it in a uintptr_t. This is safe because this + // lambda will be destroyed in ~PerformanceMainThread(). + uintptr_t self = reinterpret_cast<uintptr_t>(this); + profiler_add_state_change_callback( + // Using the "Pausing" state as "GeneratingProfile" profile happens too + // late; we can not record markers if the profiler is already paused. + ProfilingState::Pausing, + [self, innerWindowID](ProfilingState aProfilingState) { + const PerformanceMainThread* selfPtr = + reinterpret_cast<const PerformanceMainThread*>(self); + + selfPtr->GetDOMTiming()->MaybeAddLCPProfilerMarker(innerWindowID); + }, + self); + } +} + +PerformanceMainThread::~PerformanceMainThread() { + profiler_remove_state_change_callback(reinterpret_cast<uintptr_t>(this)); + mozilla::DropJSObjects(this); +} + +void PerformanceMainThread::GetMozMemory(JSContext* aCx, + JS::MutableHandle<JSObject*> aObj) { + if (!mMozMemory) { + JS::Rooted<JSObject*> mozMemoryObj(aCx, JS_NewPlainObject(aCx)); + JS::Rooted<JSObject*> gcMemoryObj(aCx, js::gc::NewMemoryInfoObject(aCx)); + if (!mozMemoryObj || !gcMemoryObj) { + MOZ_CRASH("out of memory creating performance.mozMemory"); + } + if (!JS_DefineProperty(aCx, mozMemoryObj, "gc", gcMemoryObj, + JSPROP_ENUMERATE)) { + MOZ_CRASH("out of memory creating performance.mozMemory"); + } + mMozMemory = mozMemoryObj; + mozilla::HoldJSObjects(this); + } + + aObj.set(mMozMemory); +} + +PerformanceTiming* PerformanceMainThread::Timing() { + if (!mTiming) { + // For navigation timing, the third argument (an nsIHttpChannel) is null + // since the cross-domain redirect were already checked. The last + // argument (zero time) for performance.timing is the navigation start + // value. + mTiming = new PerformanceTiming(this, mChannel, nullptr, + mDOMTiming->GetNavigationStart()); + } + + return mTiming; +} + +void PerformanceMainThread::DispatchBufferFullEvent() { + RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr); + // it bubbles, and it isn't cancelable + event->InitEvent(u"resourcetimingbufferfull"_ns, true, false); + event->SetTrusted(true); + DispatchEvent(*event); +} + +PerformanceNavigation* PerformanceMainThread::Navigation() { + if (!mNavigation) { + mNavigation = new PerformanceNavigation(this); + } + + return mNavigation; +} + +/** + * An entry should be added only after the resource is loaded. + * This method is not thread safe and can only be called on the main thread. + */ +void PerformanceMainThread::AddEntry(nsIHttpChannel* channel, + nsITimedChannel* timedChannel) { + MOZ_ASSERT(NS_IsMainThread()); + + nsAutoString initiatorType; + nsAutoString entryName; + + UniquePtr<PerformanceTimingData> performanceTimingData( + PerformanceTimingData::Create(timedChannel, channel, 0, initiatorType, + entryName)); + if (!performanceTimingData) { + return; + } + AddRawEntry(std::move(performanceTimingData), initiatorType, entryName); +} + +void PerformanceMainThread::AddEntry(const nsString& entryName, + const nsString& initiatorType, + UniquePtr<PerformanceTimingData>&& aData) { + AddRawEntry(std::move(aData), initiatorType, entryName); +} + +void PerformanceMainThread::AddRawEntry(UniquePtr<PerformanceTimingData> aData, + const nsAString& aInitiatorType, + const nsAString& aEntryName) { + // The PerformanceResourceTiming object will use the PerformanceTimingData + // object to get all the required timings. + auto entry = + MakeRefPtr<PerformanceResourceTiming>(std::move(aData), this, aEntryName); + entry->SetInitiatorType(aInitiatorType); + InsertResourceEntry(entry); +} + +void PerformanceMainThread::SetFCPTimingEntry(PerformancePaintTiming* aEntry) { + MOZ_ASSERT(aEntry); + if (!mFCPTiming) { + mFCPTiming = aEntry; + QueueEntry(aEntry); + } +} + +void PerformanceMainThread::InsertEventTimingEntry( + PerformanceEventTiming* aEventEntry) { + mPendingEventTimingEntries.insertBack(aEventEntry); + + if (mHasQueuedRefreshdriverObserver) { + return; + } + + PresShell* presShell = GetPresShell(); + if (!presShell) { + return; + } + + nsPresContext* presContext = presShell->GetPresContext(); + if (!presContext) { + return; + } + + // Using PostRefreshObserver is fine because we don't + // run any JS between the `mark paint timing` step and the + // `pending Event Timing entries` step. So mixing the order + // here is fine. + mHasQueuedRefreshdriverObserver = true; + presContext->RegisterManagedPostRefreshObserver( + new ManagedPostRefreshObserver( + presContext, [performance = RefPtr<PerformanceMainThread>(this)]( + bool aWasCanceled) { + if (!aWasCanceled) { + // XXX Should we do this even if canceled? + performance->DispatchPendingEventTimingEntries(); + } + performance->mHasQueuedRefreshdriverObserver = false; + return ManagedPostRefreshObserver::Unregister::Yes; + })); +} + +void PerformanceMainThread::BufferEventTimingEntryIfNeeded( + PerformanceEventTiming* aEventEntry) { + if (mEventTimingEntries.Length() < kDefaultEventTimingBufferSize) { + mEventTimingEntries.AppendElement(aEventEntry); + } +} + +void PerformanceMainThread::BufferLargestContentfulPaintEntryIfNeeded( + LargestContentfulPaint* aEntry) { + MOZ_ASSERT(StaticPrefs::dom_enable_largest_contentful_paint()); + if (mLargestContentfulPaintEntries.Length() < + kMaxLargestContentfulPaintBufferSize) { + mLargestContentfulPaintEntries.AppendElement(aEntry); + } +} + +void PerformanceMainThread::DispatchPendingEventTimingEntries() { + DOMHighResTimeStamp renderingTime = NowUnclamped(); + + while (!mPendingEventTimingEntries.isEmpty()) { + RefPtr<PerformanceEventTiming> entry = + mPendingEventTimingEntries.popFirst(); + + entry->SetDuration(renderingTime - entry->RawStartTime()); + IncEventCount(entry->GetName()); + + if (entry->RawDuration() >= kDefaultEventTimingMinDuration) { + QueueEntry(entry); + } + + if (!mHasDispatchedInputEvent) { + switch (entry->GetMessage()) { + case ePointerDown: { + mPendingPointerDown = entry->Clone(); + mPendingPointerDown->SetEntryType(u"first-input"_ns); + break; + } + case ePointerUp: { + if (mPendingPointerDown) { + MOZ_ASSERT(!mFirstInputEvent); + mFirstInputEvent = mPendingPointerDown.forget(); + QueueEntry(mFirstInputEvent); + SetHasDispatchedInputEvent(); + } + break; + } + case eMouseClick: + case eKeyDown: + case eMouseDown: { + mFirstInputEvent = entry->Clone(); + mFirstInputEvent->SetEntryType(u"first-input"_ns); + QueueEntry(mFirstInputEvent); + SetHasDispatchedInputEvent(); + break; + } + default: + break; + } + } + } +} + +DOMHighResTimeStamp PerformanceMainThread::GetPerformanceTimingFromString( + const nsAString& aProperty) { + // ::Measure expects the values returned from this function to be passed + // through ReduceTimePrecision already. + if (!IsPerformanceTimingAttribute(aProperty)) { + return 0; + } + // Values from Timing() are already reduced + if (aProperty.EqualsLiteral("redirectStart")) { + return Timing()->RedirectStart(); + } + if (aProperty.EqualsLiteral("redirectEnd")) { + return Timing()->RedirectEnd(); + } + if (aProperty.EqualsLiteral("fetchStart")) { + return Timing()->FetchStart(); + } + if (aProperty.EqualsLiteral("domainLookupStart")) { + return Timing()->DomainLookupStart(); + } + if (aProperty.EqualsLiteral("domainLookupEnd")) { + return Timing()->DomainLookupEnd(); + } + if (aProperty.EqualsLiteral("connectStart")) { + return Timing()->ConnectStart(); + } + if (aProperty.EqualsLiteral("secureConnectionStart")) { + return Timing()->SecureConnectionStart(); + } + if (aProperty.EqualsLiteral("connectEnd")) { + return Timing()->ConnectEnd(); + } + if (aProperty.EqualsLiteral("requestStart")) { + return Timing()->RequestStart(); + } + if (aProperty.EqualsLiteral("responseStart")) { + return Timing()->ResponseStart(); + } + if (aProperty.EqualsLiteral("responseEnd")) { + return Timing()->ResponseEnd(); + } + // Values from GetDOMTiming() are not. + DOMHighResTimeStamp retValue; + if (aProperty.EqualsLiteral("navigationStart")) { + // DOMHighResTimeStamp is in relation to navigationStart, so this will be + // zero. + retValue = GetDOMTiming()->GetNavigationStart(); + } else if (aProperty.EqualsLiteral("unloadEventStart")) { + retValue = GetDOMTiming()->GetUnloadEventStart(); + } else if (aProperty.EqualsLiteral("unloadEventEnd")) { + retValue = GetDOMTiming()->GetUnloadEventEnd(); + } else if (aProperty.EqualsLiteral("domLoading")) { + retValue = GetDOMTiming()->GetDomLoading(); + } else if (aProperty.EqualsLiteral("domInteractive")) { + retValue = GetDOMTiming()->GetDomInteractive(); + } else if (aProperty.EqualsLiteral("domContentLoadedEventStart")) { + retValue = GetDOMTiming()->GetDomContentLoadedEventStart(); + } else if (aProperty.EqualsLiteral("domContentLoadedEventEnd")) { + retValue = GetDOMTiming()->GetDomContentLoadedEventEnd(); + } else if (aProperty.EqualsLiteral("domComplete")) { + retValue = GetDOMTiming()->GetDomComplete(); + } else if (aProperty.EqualsLiteral("loadEventStart")) { + retValue = GetDOMTiming()->GetLoadEventStart(); + } else if (aProperty.EqualsLiteral("loadEventEnd")) { + retValue = GetDOMTiming()->GetLoadEventEnd(); + } else { + MOZ_CRASH( + "IsPerformanceTimingAttribute and GetPerformanceTimingFromString are " + "out " + "of sync"); + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + retValue, GetRandomTimelineSeed(), mRTPCallerType); +} + +void PerformanceMainThread::InsertUserEntry(PerformanceEntry* aEntry) { + MOZ_ASSERT(NS_IsMainThread()); + + nsAutoCString uri; + double markCreationEpoch = 0; + + if (StaticPrefs::dom_performance_enable_user_timing_logging() || + StaticPrefs::dom_performance_enable_notify_performance_timing()) { + nsresult rv = NS_ERROR_FAILURE; + nsCOMPtr<nsPIDOMWindowInner> owner = GetOwner(); + if (owner && owner->GetDocumentURI()) { + rv = owner->GetDocumentURI()->GetHost(uri); + } + + if (NS_FAILED(rv)) { + // If we have no URI, just put in "none". + uri.AssignLiteral("none"); + } + + // PR_Now() returns a signed 64-bit integer. Since it represents a + // timestamp, only ~32-bits will represent the value which should safely fit + // into a double. + markCreationEpoch = static_cast<double>(PR_Now() / PR_USEC_PER_MSEC); + + if (StaticPrefs::dom_performance_enable_user_timing_logging()) { + Performance::LogEntry(aEntry, uri); + } + } + + if (StaticPrefs::dom_performance_enable_notify_performance_timing()) { + TimingNotification(aEntry, uri, markCreationEpoch); + } + + Performance::InsertUserEntry(aEntry); +} + +TimeStamp PerformanceMainThread::CreationTimeStamp() const { + return GetDOMTiming()->GetNavigationStartTimeStamp(); +} + +DOMHighResTimeStamp PerformanceMainThread::CreationTime() const { + return GetDOMTiming()->GetNavigationStart(); +} + +void PerformanceMainThread::CreateNavigationTimingEntry() { + MOZ_ASSERT(!mDocEntry, "mDocEntry should be null."); + + if (!StaticPrefs::dom_enable_performance_navigation_timing()) { + return; + } + + nsAutoString name; + GetURLSpecFromChannel(mChannel, name); + + UniquePtr<PerformanceTimingData> timing( + new PerformanceTimingData(mChannel, nullptr, 0)); + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel); + if (httpChannel) { + timing->SetPropertiesFromHttpChannel(httpChannel, mChannel); + } + + mDocEntry = new PerformanceNavigationTiming(std::move(timing), this, name); +} + +void PerformanceMainThread::UpdateNavigationTimingEntry() { + if (!mDocEntry) { + return; + } + + // Let's update some values. + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel); + if (httpChannel) { + mDocEntry->UpdatePropertiesFromHttpChannel(httpChannel, mChannel); + } +} + +void PerformanceMainThread::QueueNavigationTimingEntry() { + if (!mDocEntry) { + return; + } + + UpdateNavigationTimingEntry(); + + QueueEntry(mDocEntry); +} + +void PerformanceMainThread::QueueLargestContentfulPaintEntry( + LargestContentfulPaint* aEntry) { + MOZ_ASSERT(StaticPrefs::dom_enable_largest_contentful_paint()); + QueueEntry(aEntry); +} + +EventCounts* PerformanceMainThread::EventCounts() { + MOZ_ASSERT(StaticPrefs::dom_enable_event_timing()); + return mEventCounts; +} + +void PerformanceMainThread::GetEntries( + nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + aRetval = mResourceEntries.Clone(); + aRetval.AppendElements(mUserEntries); + + if (mDocEntry) { + aRetval.AppendElement(mDocEntry); + } + + if (mFCPTiming) { + aRetval.AppendElement(mFCPTiming); + } + aRetval.Sort(PerformanceEntryComparator()); +} + +void PerformanceMainThread::GetEntriesByType( + const nsAString& aEntryType, nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + RefPtr<nsAtom> type = NS_Atomize(aEntryType); + if (type == nsGkAtoms::navigation) { + aRetval.Clear(); + + if (mDocEntry) { + aRetval.AppendElement(mDocEntry); + } + return; + } + + if (type == nsGkAtoms::paint) { + if (mFCPTiming) { + aRetval.AppendElement(mFCPTiming); + return; + } + } + + if (type == nsGkAtoms::firstInput && mFirstInputEvent) { + aRetval.AppendElement(mFirstInputEvent); + return; + } + + Performance::GetEntriesByType(aEntryType, aRetval); +} +void PerformanceMainThread::GetEntriesByTypeForObserver( + const nsAString& aEntryType, nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + if (aEntryType.EqualsLiteral("event")) { + aRetval.AppendElements(mEventTimingEntries); + return; + } + + if (StaticPrefs::dom_enable_largest_contentful_paint()) { + if (aEntryType.EqualsLiteral("largest-contentful-paint")) { + aRetval.AppendElements(mLargestContentfulPaintEntries); + return; + } + } + + return GetEntriesByType(aEntryType, aRetval); +} + +void PerformanceMainThread::GetEntriesByName( + const nsAString& aName, const Optional<nsAString>& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + Performance::GetEntriesByName(aName, aEntryType, aRetval); + + if (mFCPTiming && mFCPTiming->GetName()->Equals(aName) && + (!aEntryType.WasPassed() || + mFCPTiming->GetEntryType()->Equals(aEntryType.Value()))) { + aRetval.AppendElement(mFCPTiming); + return; + } + + // The navigation entry is the first one. If it exists and the name matches, + // let put it in front. + if (mDocEntry && mDocEntry->GetName()->Equals(aName)) { + aRetval.InsertElementAt(0, mDocEntry); + return; + } +} + +mozilla::PresShell* PerformanceMainThread::GetPresShell() { + nsIGlobalObject* ownerGlobal = GetOwnerGlobal(); + if (!ownerGlobal) { + return nullptr; + } + if (Document* doc = ownerGlobal->GetAsInnerWindow()->GetExtantDoc()) { + return doc->GetPresShell(); + } + return nullptr; +} + +void PerformanceMainThread::IncEventCount(const nsAtom* aType) { + MOZ_ASSERT(StaticPrefs::dom_enable_event_timing()); + + // This occurs when the pref was false when the performance + // object was first created, and became true later. It's + // okay to return early because eventCounts is not exposed. + if (!mEventCounts) { + return; + } + + ErrorResult rv; + uint64_t count = EventCounts_Binding::MaplikeHelpers::Get( + mEventCounts, nsDependentAtomString(aType), rv); + MOZ_ASSERT(!rv.Failed()); + EventCounts_Binding::MaplikeHelpers::Set( + mEventCounts, nsDependentAtomString(aType), ++count, rv); + MOZ_ASSERT(!rv.Failed()); +} + +size_t PerformanceMainThread::SizeOfEventEntries( + mozilla::MallocSizeOf aMallocSizeOf) const { + size_t eventEntries = 0; + for (const PerformanceEventTiming* entry : mEventTimingEntries) { + eventEntries += entry->SizeOfIncludingThis(aMallocSizeOf); + } + return eventEntries; +} + +void PerformanceMainThread::ProcessElementTiming() { + if (!StaticPrefs::dom_enable_largest_contentful_paint()) { + return; + } + const bool shouldLCPDataEmpty = + HasDispatchedInputEvent() || HasDispatchedScrollEvent(); + MOZ_ASSERT_IF(shouldLCPDataEmpty, + mTextFrameUnions.IsEmpty() && mImageLCPEntryMap.IsEmpty()); + + if (shouldLCPDataEmpty) { + return; + } + + nsPresContext* presContext = GetPresShell()->GetPresContext(); + MOZ_ASSERT(presContext); + + // After https://github.com/w3c/largest-contentful-paint/issues/104 is + // resolved, LargestContentfulPaint and FirstContentfulPaint should + // be using the same timestamp, which should be the same timestamp + // as to what https://w3c.github.io/paint-timing/#mark-paint-timing step 2 + // defines. + // TODO(sefeng): Check the timestamp after this issue is resolved. + TimeStamp rawNowTime = presContext->GetMarkPaintTimingStart(); + + MOZ_ASSERT(GetOwnerGlobal()); + Document* document = GetOwnerGlobal()->GetAsInnerWindow()->GetExtantDoc(); + if (!document || + !nsContentUtils::GetInProcessSubtreeRootDocument(document)->IsActive()) { + return; + } + + nsTArray<ImagePendingRendering> imagesPendingRendering = + std::move(mImagesPendingRendering); + for (const auto& imagePendingRendering : imagesPendingRendering) { + RefPtr<Element> element = imagePendingRendering.GetElement(); + if (!element) { + continue; + } + + MOZ_ASSERT(imagePendingRendering.mLoadTime <= rawNowTime); + if (imgRequestProxy* requestProxy = + imagePendingRendering.GetImgRequestProxy()) { + LCPHelpers::CreateLCPEntryForImage( + this, element, requestProxy, imagePendingRendering.mLoadTime, + rawNowTime, imagePendingRendering.mLCPImageEntryKey); + } + } + + MOZ_ASSERT(mImagesPendingRendering.IsEmpty()); +} + +void PerformanceMainThread::FinalizeLCPEntriesForText() { + nsPresContext* presContext = GetPresShell()->GetPresContext(); + MOZ_ASSERT(presContext); + + bool canFinalize = StaticPrefs::dom_enable_largest_contentful_paint() && + !presContext->HasStoppedGeneratingLCP(); + nsTHashMap<nsRefPtrHashKey<Element>, nsRect> textFrameUnion = + std::move(GetTextFrameUnions()); + if (canFinalize) { + for (const auto& textFrameUnion : textFrameUnion) { + LCPHelpers::FinalizeLCPEntryForText( + this, presContext->GetMarkPaintTimingStart(), textFrameUnion.GetKey(), + textFrameUnion.GetData(), presContext); + } + } + MOZ_ASSERT(GetTextFrameUnions().IsEmpty()); +} + +void PerformanceMainThread::StoreImageLCPEntry( + Element* aElement, imgRequestProxy* aImgRequestProxy, + LargestContentfulPaint* aEntry) { + mImageLCPEntryMap.InsertOrUpdate({aElement, aImgRequestProxy}, aEntry); +} + +already_AddRefed<LargestContentfulPaint> +PerformanceMainThread::GetImageLCPEntry(Element* aElement, + imgRequestProxy* aImgRequestProxy) { + Maybe<RefPtr<LargestContentfulPaint>> entry = + mImageLCPEntryMap.Extract({aElement, aImgRequestProxy}); + if (entry.isNothing()) { + return nullptr; + } + + Document* doc = aElement->GetComposedDoc(); + MOZ_ASSERT(doc, "Element should be connected when it's painted"); + + Maybe<LCPImageEntryKey>& contentIdentifier = + entry.value()->GetLCPImageEntryKey(); + if (contentIdentifier.isSome()) { + doc->ContentIdentifiersForLCP().EnsureRemoved(contentIdentifier.value()); + contentIdentifier.reset(); + } + + return entry.value().forget(); +} + +bool PerformanceMainThread::UpdateLargestContentfulPaintSize(double aSize) { + if (aSize > mLargestContentfulPaintSize) { + mLargestContentfulPaintSize = aSize; + return true; + } + return false; +} + +void PerformanceMainThread::SetHasDispatchedScrollEvent() { + mHasDispatchedScrollEvent = true; + ClearGeneratedTempDataForLCP(); +} + +void PerformanceMainThread::SetHasDispatchedInputEvent() { + mHasDispatchedInputEvent = true; + ClearGeneratedTempDataForLCP(); +} + +void PerformanceMainThread::ClearGeneratedTempDataForLCP() { + mTextFrameUnions.Clear(); + mImageLCPEntryMap.Clear(); + mImagesPendingRendering.Clear(); + + nsIGlobalObject* ownerGlobal = GetOwnerGlobal(); + if (!ownerGlobal) { + return; + } + + if (Document* document = ownerGlobal->GetAsInnerWindow()->GetExtantDoc()) { + document->ContentIdentifiersForLCP().Clear(); + } +} +} // namespace mozilla::dom 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<LCPEntryHashEntry, RefPtr<LargestContentfulPaint>>; + +using TextFrameUnions = nsTHashMap<nsRefPtrHashKey<Element>, 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<PerformanceTimingData>&& aData) override; + + // aPerformanceTimingData must be non-null. + void AddRawEntry(UniquePtr<PerformanceTimingData> 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<JSObject*> 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<RefPtr<PerformanceEntry>>& aRetval) override; + + // Return entries which qualify availableFromTimeline boolean check + virtual void GetEntriesByType( + const nsAString& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& 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<RefPtr<PerformanceEntry>>& aRetval) override; + virtual void GetEntriesByName( + const nsAString& aName, const Optional<nsAString>& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& 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<LargestContentfulPaint> GetImageLCPEntry( + Element* aElement, imgRequestProxy* aImgRequestProxy); + + bool UpdateLargestContentfulPaintSize(double aSize); + double GetLargestContentfulPaintSize() const { + return mLargestContentfulPaintSize; + } + + nsTHashMap<nsRefPtrHashKey<Element>, 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<PerformanceNavigationTiming> mDocEntry; + RefPtr<nsDOMNavigationTiming> mDOMTiming; + nsCOMPtr<nsITimedChannel> mChannel; + RefPtr<PerformanceTiming> mTiming; + RefPtr<PerformanceNavigation> mNavigation; + RefPtr<PerformancePaintTiming> mFCPTiming; + JS::Heap<JSObject*> mMozMemory; + + nsTArray<RefPtr<PerformanceEventTiming>> mEventTimingEntries; + nsTArray<RefPtr<LargestContentfulPaint>> mLargestContentfulPaintEntries; + + AutoCleanLinkedList<RefPtr<PerformanceEventTiming>> + mPendingEventTimingEntries; + bool mHasDispatchedInputEvent = false; + bool mHasDispatchedScrollEvent = false; + + RefPtr<PerformanceEventTiming> mFirstInputEvent; + RefPtr<PerformanceEventTiming> mPendingPointerDown; + + private: + void SetHasDispatchedInputEvent(); + + bool mHasQueuedRefreshdriverObserver = false; + + RefPtr<class EventCounts> mEventCounts; + void IncEventCount(const nsAtom* aType); + + PresShell* GetPresShell(); + + nsTArray<ImagePendingRendering> 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<LargestContentfulPaint>* 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<Element>)", + aFlags); + } +} + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceMainThread_h diff --git a/dom/performance/PerformanceMark.cpp b/dom/performance/PerformanceMark.cpp new file mode 100644 index 0000000000..57258e2107 --- /dev/null +++ b/dom/performance/PerformanceMark.cpp @@ -0,0 +1,124 @@ +/* -*- 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 "PerformanceMark.h" +#include "MainThreadUtils.h" +#include "nsContentUtils.h" +#include "Performance.h" +#include "mozilla/dom/MessagePortBinding.h" +#include "mozilla/dom/PerformanceBinding.h" +#include "mozilla/dom/PerformanceMarkBinding.h" + +using namespace mozilla::dom; + +PerformanceMark::PerformanceMark(nsISupports* aParent, const nsAString& aName, + DOMHighResTimeStamp aStartTime, + const JS::Handle<JS::Value>& aDetail, + DOMHighResTimeStamp aUnclampedStartTime) + : PerformanceEntry(aParent, aName, u"mark"_ns), + mStartTime(aStartTime), + mDetail(aDetail), + mUnclampedStartTime(aUnclampedStartTime) { + mozilla::HoldJSObjects(this); +} + +already_AddRefed<PerformanceMark> PerformanceMark::Constructor( + const GlobalObject& aGlobal, const nsAString& aMarkName, + const PerformanceMarkOptions& aMarkOptions, ErrorResult& aRv) { + const nsCOMPtr<nsIGlobalObject> global = + do_QueryInterface(aGlobal.GetAsSupports()); + return PerformanceMark::Constructor(aGlobal.Context(), global, aMarkName, + aMarkOptions, aRv); +} + +already_AddRefed<PerformanceMark> PerformanceMark::Constructor( + JSContext* aCx, nsIGlobalObject* aGlobal, const nsAString& aMarkName, + const PerformanceMarkOptions& aMarkOptions, ErrorResult& aRv) { + RefPtr<Performance> performance = Performance::Get(aCx, aGlobal); + if (!performance) { + // This is similar to the message that occurs when accessing `performance` + // from outside a valid global. + aRv.ThrowTypeError( + "can't access PerformanceMark constructor, performance is null"); + return nullptr; + } + + if (performance->IsGlobalObjectWindow() && + performance->IsPerformanceTimingAttribute(aMarkName)) { + aRv.ThrowSyntaxError("markName cannot be a performance timing attribute"); + return nullptr; + } + + DOMHighResTimeStamp startTime = aMarkOptions.mStartTime.WasPassed() + ? aMarkOptions.mStartTime.Value() + : performance->Now(); + // We need to get the unclamped start time to be able to add profiler markers + // with precise time/duration. This is not exposed to web and only used by the + // profiler. + // If a mStartTime is passed by the user, we will always have a clamped value. + DOMHighResTimeStamp unclampedStartTime = aMarkOptions.mStartTime.WasPassed() + ? startTime + : performance->NowUnclamped(); + if (startTime < 0) { + aRv.ThrowTypeError("Expected startTime >= 0"); + return nullptr; + } + + JS::Rooted<JS::Value> detail(aCx); + if (aMarkOptions.mDetail.isNullOrUndefined()) { + detail.setNull(); + } else { + StructuredSerializeOptions serializeOptions; + JS::Rooted<JS::Value> valueToClone(aCx, aMarkOptions.mDetail); + nsContentUtils::StructuredClone(aCx, aGlobal, valueToClone, + serializeOptions, &detail, aRv); + if (aRv.Failed()) { + return nullptr; + } + } + + return do_AddRef(new PerformanceMark(aGlobal, aMarkName, startTime, detail, + unclampedStartTime)); +} + +PerformanceMark::~PerformanceMark() { mozilla::DropJSObjects(this); } + +NS_IMPL_CYCLE_COLLECTION_CLASS(PerformanceMark) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(PerformanceMark, + PerformanceEntry) + tmp->mDetail.setUndefined(); + mozilla::DropJSObjects(tmp); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(PerformanceMark, + PerformanceEntry) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(PerformanceMark, + PerformanceEntry) + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mDetail) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(PerformanceMark, + PerformanceEntry) + +JSObject* PerformanceMark::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return PerformanceMark_Binding::Wrap(aCx, this, aGivenProto); +} + +void PerformanceMark::GetDetail(JSContext* aCx, + JS::MutableHandle<JS::Value> aRetval) { + // Return a copy so that this method always returns the value it is set to + // (i.e. it'll return the same value even if the caller assigns to it). Note + // that if detail is an object, its contents can be mutated and this is + // expected. + aRetval.set(mDetail); +} + +size_t PerformanceMark::SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} diff --git a/dom/performance/PerformanceMark.h b/dom/performance/PerformanceMark.h new file mode 100644 index 0000000000..a67564442c --- /dev/null +++ b/dom/performance/PerformanceMark.h @@ -0,0 +1,68 @@ +/* -*- 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_performancemark_h___ +#define mozilla_dom_performancemark_h___ + +#include "mozilla/dom/PerformanceEntry.h" +#include "mozilla/ProfilerMarkers.h" + +namespace mozilla::dom { + +struct PerformanceMarkOptions; + +// http://www.w3.org/TR/user-timing/#performancemark +class PerformanceMark final : public PerformanceEntry { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(PerformanceMark, + PerformanceEntry); + + private: + PerformanceMark(nsISupports* aParent, const nsAString& aName, + DOMHighResTimeStamp aStartTime, + const JS::Handle<JS::Value>& aDetail, + DOMHighResTimeStamp aUnclampedStartTime); + + public: + static already_AddRefed<PerformanceMark> Constructor( + const GlobalObject& aGlobal, const nsAString& aMarkName, + const PerformanceMarkOptions& aMarkOptions, ErrorResult& aRv); + + static already_AddRefed<PerformanceMark> Constructor( + JSContext* aCx, nsIGlobalObject* aGlobal, const nsAString& aMarkName, + const PerformanceMarkOptions& aMarkOptions, ErrorResult& aRv); + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + virtual DOMHighResTimeStamp StartTime() const override { return mStartTime; } + + virtual DOMHighResTimeStamp UnclampedStartTime() const override { + MOZ_ASSERT(profiler_thread_is_being_profiled_for_markers(), + "This should only be called when the Gecko Profiler is active."); + return mUnclampedStartTime; + } + + void GetDetail(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval); + + size_t SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const override; + + protected: + virtual ~PerformanceMark(); + DOMHighResTimeStamp mStartTime; + + private: + JS::Heap<JS::Value> mDetail; + // This is used by the Gecko Profiler only to be able to add precise markers. + // It's not exposed to JS + DOMHighResTimeStamp mUnclampedStartTime; +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_performancemark_h___ */ diff --git a/dom/performance/PerformanceMeasure.cpp b/dom/performance/PerformanceMeasure.cpp new file mode 100644 index 0000000000..d276162b42 --- /dev/null +++ b/dom/performance/PerformanceMeasure.cpp @@ -0,0 +1,62 @@ +/* -*- 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 "PerformanceMeasure.h" +#include "MainThreadUtils.h" +#include "mozilla/dom/PerformanceMeasureBinding.h" + +using namespace mozilla::dom; + +PerformanceMeasure::PerformanceMeasure(nsISupports* aParent, + const nsAString& aName, + DOMHighResTimeStamp aStartTime, + DOMHighResTimeStamp aEndTime, + const JS::Handle<JS::Value>& aDetail) + : PerformanceEntry(aParent, aName, u"measure"_ns), + mStartTime(aStartTime), + mDuration(aEndTime - aStartTime), + mDetail(aDetail) { + mozilla::HoldJSObjects(this); +} + +PerformanceMeasure::~PerformanceMeasure() { mozilla::DropJSObjects(this); } + +NS_IMPL_CYCLE_COLLECTION_CLASS(PerformanceMeasure) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(PerformanceMeasure, + PerformanceEntry) + tmp->mDetail.setUndefined(); + mozilla::DropJSObjects(tmp); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(PerformanceMeasure, + PerformanceEntry) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(PerformanceMeasure, + PerformanceEntry) + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mDetail) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(PerformanceMeasure, + PerformanceEntry) + +JSObject* PerformanceMeasure::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return PerformanceMeasure_Binding::Wrap(aCx, this, aGivenProto); +} + +void PerformanceMeasure::GetDetail(JSContext* aCx, + JS::MutableHandle<JS::Value> aRetval) { + // Return a copy so that this method always returns the value it is set to + // (i.e. it'll return the same value even if the caller assigns to it). Note + // that if detail is an object, its contents can be mutated and this is + // expected. + aRetval.set(mDetail); +} + +size_t PerformanceMeasure::SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} diff --git a/dom/performance/PerformanceMeasure.h b/dom/performance/PerformanceMeasure.h new file mode 100644 index 0000000000..7ac9ceb16d --- /dev/null +++ b/dom/performance/PerformanceMeasure.h @@ -0,0 +1,49 @@ +/* -*- 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_performancemeasure_h___ +#define mozilla_dom_performancemeasure_h___ + +#include "mozilla/dom/PerformanceEntry.h" + +namespace mozilla::dom { + +// http://www.w3.org/TR/user-timing/#performancemeasure +class PerformanceMeasure final : public PerformanceEntry { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(PerformanceMeasure, + PerformanceEntry); + + PerformanceMeasure(nsISupports* aParent, const nsAString& aName, + DOMHighResTimeStamp aStartTime, + DOMHighResTimeStamp aEndTime, + const JS::Handle<JS::Value>& aDetail); + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + virtual DOMHighResTimeStamp StartTime() const override { return mStartTime; } + + virtual DOMHighResTimeStamp Duration() const override { return mDuration; } + + void GetDetail(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval); + + size_t SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const override; + + protected: + virtual ~PerformanceMeasure(); + DOMHighResTimeStamp mStartTime; + DOMHighResTimeStamp mDuration; + + private: + JS::Heap<JS::Value> mDetail; +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_performancemeasure_h___ */ diff --git a/dom/performance/PerformanceNavigation.cpp b/dom/performance/PerformanceNavigation.cpp new file mode 100644 index 0000000000..bbfdd4a982 --- /dev/null +++ b/dom/performance/PerformanceNavigation.cpp @@ -0,0 +1,31 @@ +/* -*- 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 "PerformanceNavigation.h" +#include "PerformanceTiming.h" +#include "mozilla/dom/PerformanceNavigationBinding.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PerformanceNavigation, mPerformance) + +PerformanceNavigation::PerformanceNavigation(Performance* aPerformance) + : mPerformance(aPerformance) { + MOZ_ASSERT(aPerformance, "Parent performance object should be provided"); +} + +PerformanceNavigation::~PerformanceNavigation() = default; + +JSObject* PerformanceNavigation::WrapObject(JSContext* cx, + JS::Handle<JSObject*> aGivenProto) { + return PerformanceNavigation_Binding::Wrap(cx, this, aGivenProto); +} + +uint16_t PerformanceNavigation::RedirectCount() const { + return GetPerformanceTiming()->Data()->GetRedirectCount(); +} + +} // namespace mozilla::dom diff --git a/dom/performance/PerformanceNavigation.h b/dom/performance/PerformanceNavigation.h new file mode 100644 index 0000000000..2f6e21fe65 --- /dev/null +++ b/dom/performance/PerformanceNavigation.h @@ -0,0 +1,50 @@ +/* -*- 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_PerformanceNavigation_h +#define mozilla_dom_PerformanceNavigation_h + +#include "mozilla/Attributes.h" +#include "mozilla/dom/Performance.h" +#include "nsDOMNavigationTiming.h" +#include "nsWrapperCache.h" + +namespace mozilla::dom { + +// Script "performance.navigation" object +class PerformanceNavigation final : public nsWrapperCache { + public: + explicit PerformanceNavigation(Performance* aPerformance); + + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(PerformanceNavigation) + NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(PerformanceNavigation) + + nsDOMNavigationTiming* GetDOMTiming() const { + return mPerformance->GetDOMTiming(); + } + + PerformanceTiming* GetPerformanceTiming() const { + return mPerformance->Timing(); + } + + Performance* GetParentObject() const { return mPerformance; } + + virtual JSObject* WrapObject(JSContext* cx, + JS::Handle<JSObject*> aGivenProto) override; + + // PerformanceNavigation WebIDL methods + uint16_t Type() const { return GetDOMTiming()->GetType(); } + + uint16_t RedirectCount() const; + + private: + ~PerformanceNavigation(); + RefPtr<Performance> mPerformance; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceNavigation_h diff --git a/dom/performance/PerformanceNavigationTiming.cpp b/dom/performance/PerformanceNavigationTiming.cpp new file mode 100644 index 0000000000..6bd1cc1fbe --- /dev/null +++ b/dom/performance/PerformanceNavigationTiming.cpp @@ -0,0 +1,156 @@ +/* -*- 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/PerformanceNavigationTiming.h" +#include "mozilla/dom/PerformanceNavigationTimingBinding.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/StaticPrefs_privacy.h" + +using namespace mozilla::dom; + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceNavigationTiming) +NS_INTERFACE_MAP_END_INHERITING(PerformanceResourceTiming) + +NS_IMPL_ADDREF_INHERITED(PerformanceNavigationTiming, PerformanceResourceTiming) +NS_IMPL_RELEASE_INHERITED(PerformanceNavigationTiming, + PerformanceResourceTiming) + +JSObject* PerformanceNavigationTiming::WrapObject( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return PerformanceNavigationTiming_Binding::Wrap(aCx, this, aGivenProto); +} + +#define REDUCE_TIME_PRECISION \ + return nsRFPService::ReduceTimePrecisionAsMSecs( \ + rawValue, mPerformance->GetRandomTimelineSeed(), \ + mPerformance->GetRTPCallerType()) + +DOMHighResTimeStamp PerformanceNavigationTiming::UnloadEventStart() const { + DOMHighResTimeStamp rawValue = 0; + /* + * Per Navigation Timing Level 2, the value is 0 if + * a. there is no previous document or + * b. the same-origin-check fails. + * + * The same-origin-check is defined as: + * 1. If the previous document exists and its origin is not same + * origin as the current document's origin, return "fail". + * 2. Let request be the current document's request. + * 3. If request's redirect count is not zero, and all of request's + * HTTP redirects have the same origin as the current document, + * return "pass". + * 4. Otherwise, return "fail". + */ + if (mTimingData->AllRedirectsSameOrigin()) { // same-origin-check:2/3 + /* + * GetUnloadEventStartHighRes returns 0 if + * 1. there is no previous document (a, above) or + * 2. the current URI does not have the same origin as + * the previous document's URI. (same-origin-check:1) + */ + rawValue = mPerformance->GetDOMTiming()->GetUnloadEventStartHighRes(); + } + + REDUCE_TIME_PRECISION; +} + +DOMHighResTimeStamp PerformanceNavigationTiming::UnloadEventEnd() const { + DOMHighResTimeStamp rawValue = 0; + + // See comments in PerformanceNavigationTiming::UnloadEventEnd(). + if (mTimingData->AllRedirectsSameOrigin()) { + rawValue = mPerformance->GetDOMTiming()->GetUnloadEventEndHighRes(); + } + + REDUCE_TIME_PRECISION; +} + +DOMHighResTimeStamp PerformanceNavigationTiming::DomInteractive() const { + DOMHighResTimeStamp rawValue = + mPerformance->GetDOMTiming()->GetDomInteractiveHighRes(); + + REDUCE_TIME_PRECISION; +} + +DOMHighResTimeStamp PerformanceNavigationTiming::DomContentLoadedEventStart() + const { + DOMHighResTimeStamp rawValue = + mPerformance->GetDOMTiming()->GetDomContentLoadedEventStartHighRes(); + + REDUCE_TIME_PRECISION; +} + +DOMHighResTimeStamp PerformanceNavigationTiming::DomContentLoadedEventEnd() + const { + DOMHighResTimeStamp rawValue = + mPerformance->GetDOMTiming()->GetDomContentLoadedEventEndHighRes(); + + REDUCE_TIME_PRECISION; +} + +DOMHighResTimeStamp PerformanceNavigationTiming::DomComplete() const { + DOMHighResTimeStamp rawValue = + mPerformance->GetDOMTiming()->GetDomCompleteHighRes(); + + REDUCE_TIME_PRECISION; +} + +DOMHighResTimeStamp PerformanceNavigationTiming::LoadEventStart() const { + DOMHighResTimeStamp rawValue = + mPerformance->GetDOMTiming()->GetLoadEventStartHighRes(); + + REDUCE_TIME_PRECISION; +} + +DOMHighResTimeStamp PerformanceNavigationTiming::LoadEventEnd() const { + DOMHighResTimeStamp rawValue = + mPerformance->GetDOMTiming()->GetLoadEventEndHighRes(); + + REDUCE_TIME_PRECISION; +} + +NavigationType PerformanceNavigationTiming::Type() const { + switch (mPerformance->GetDOMTiming()->GetType()) { + case nsDOMNavigationTiming::TYPE_NAVIGATE: + return NavigationType::Navigate; + break; + case nsDOMNavigationTiming::TYPE_RELOAD: + return NavigationType::Reload; + break; + case nsDOMNavigationTiming::TYPE_BACK_FORWARD: + return NavigationType::Back_forward; + break; + default: + // The type is TYPE_RESERVED or some other value that was later added. + // We fallback to the default of Navigate. + return NavigationType::Navigate; + } +} + +uint16_t PerformanceNavigationTiming::RedirectCount() const { + return mTimingData->GetRedirectCount(); +} + +DOMHighResTimeStamp PerformanceNavigationTiming::RedirectStart( + nsIPrincipal& aSubjectPrincipal) const { + return PerformanceResourceTiming::RedirectStart( + aSubjectPrincipal, true /* aEnsureSameOriginAndIgnoreTAO */); +} + +DOMHighResTimeStamp PerformanceNavigationTiming::RedirectEnd( + nsIPrincipal& aSubjectPrincipal) const { + return PerformanceResourceTiming::RedirectEnd( + aSubjectPrincipal, true /* aEnsureSameOriginAndIgnoreTAO */); +} + +void PerformanceNavigationTiming::UpdatePropertiesFromHttpChannel( + nsIHttpChannel* aHttpChannel, nsITimedChannel* aChannel) { + mTimingData->SetPropertiesFromHttpChannel(aHttpChannel, aChannel); +} + +bool PerformanceNavigationTiming::Enabled(JSContext* aCx, JSObject* aGlobal) { + return StaticPrefs::dom_enable_performance_navigation_timing(); +} diff --git a/dom/performance/PerformanceNavigationTiming.h b/dom/performance/PerformanceNavigationTiming.h new file mode 100644 index 0000000000..2a10b34581 --- /dev/null +++ b/dom/performance/PerformanceNavigationTiming.h @@ -0,0 +1,93 @@ +/* -*- 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_PerformanceNavigationTiming_h___ +#define mozilla_dom_PerformanceNavigationTiming_h___ + +#include <stdint.h> +#include <utility> +#include "js/RootingAPI.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/dom/PerformanceNavigationTimingBinding.h" +#include "mozilla/dom/PerformanceResourceTiming.h" +#include "nsDOMNavigationTiming.h" +#include "nsISupports.h" +#include "nsLiteralString.h" +#include "nsString.h" +#include "nsTLiteralString.h" + +class JSObject; +class nsIHttpChannel; +class nsITimedChannel; +struct JSContext; + +namespace mozilla::dom { + +class Performance; +class PerformanceTimingData; + +// https://www.w3.org/TR/navigation-timing-2/#sec-PerformanceNavigationTiming +class PerformanceNavigationTiming final : public PerformanceResourceTiming { + public: + NS_DECL_ISUPPORTS_INHERITED + + // Note that aPerformanceTiming must be initalized with zeroTime = 0 + // so that timestamps are relative to startTime, as opposed to the + // performance.timing object for which timestamps are absolute and has a + // zeroTime initialized to navigationStart + // aPerformanceTiming and aPerformance must be non-null. + PerformanceNavigationTiming( + UniquePtr<PerformanceTimingData>&& aPerformanceTiming, + Performance* aPerformance, const nsAString& aName) + : PerformanceResourceTiming(std::move(aPerformanceTiming), aPerformance, + aName) { + SetEntryType(u"navigation"_ns); + SetInitiatorType(u"navigation"_ns); + } + + DOMHighResTimeStamp Duration() const override { + return LoadEventEnd() - StartTime(); + } + + DOMHighResTimeStamp StartTime() const override { return 0; } + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + DOMHighResTimeStamp UnloadEventStart() const; + DOMHighResTimeStamp UnloadEventEnd() const; + + DOMHighResTimeStamp DomInteractive() const; + DOMHighResTimeStamp DomContentLoadedEventStart() const; + DOMHighResTimeStamp DomContentLoadedEventEnd() const; + DOMHighResTimeStamp DomComplete() const; + DOMHighResTimeStamp LoadEventStart() const; + DOMHighResTimeStamp LoadEventEnd() const; + + DOMHighResTimeStamp RedirectStart( + nsIPrincipal& aSubjectPrincipal) const override; + DOMHighResTimeStamp RedirectEnd( + nsIPrincipal& aSubjectPrincipal) const override; + + NavigationType Type() const; + uint16_t RedirectCount() const; + + void UpdatePropertiesFromHttpChannel(nsIHttpChannel* aHttpChannel, + nsITimedChannel* aChannel); + + /* + * For use with the WebIDL Func attribute to determine whether + * window.PerformanceNavigationTiming is exposed. + */ + static bool Enabled(JSContext* aCx, JSObject* aGlobal); + + private: + ~PerformanceNavigationTiming() = default; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceNavigationTiming_h___ diff --git a/dom/performance/PerformanceObserver.cpp b/dom/performance/PerformanceObserver.cpp new file mode 100644 index 0000000000..d5d1725c57 --- /dev/null +++ b/dom/performance/PerformanceObserver.cpp @@ -0,0 +1,384 @@ +/* -*- 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 "PerformanceObserver.h" + +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/PerformanceBinding.h" +#include "mozilla/dom/PerformanceEntryBinding.h" +#include "mozilla/dom/PerformanceObserverBinding.h" +#include "mozilla/dom/WorkerScope.h" +#include "mozilla/StaticPrefs_dom.h" +#include "nsIScriptError.h" +#include "nsPIDOMWindow.h" +#include "nsQueryObject.h" +#include "nsString.h" +#include "PerformanceEntry.h" +#include "LargestContentfulPaint.h" +#include "PerformanceObserverEntryList.h" + +using namespace mozilla; +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PerformanceObserver) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(PerformanceObserver) + tmp->Disconnect(); + NS_IMPL_CYCLE_COLLECTION_UNLINK(mCallback) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mPerformance) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mQueuedEntries) + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(PerformanceObserver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCallback) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPerformance) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mQueuedEntries) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(PerformanceObserver) +NS_IMPL_CYCLE_COLLECTING_RELEASE(PerformanceObserver) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceObserver) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +const char UnsupportedEntryTypesIgnoredMsgId[] = "UnsupportedEntryTypesIgnored"; +const char AllEntryTypesIgnoredMsgId[] = "AllEntryTypesIgnored"; + +PerformanceObserver::PerformanceObserver(nsPIDOMWindowInner* aOwner, + PerformanceObserverCallback& aCb) + : mOwner(aOwner), + mCallback(&aCb), + mObserverType(ObserverTypeUndefined), + mConnected(false) { + MOZ_ASSERT(mOwner); + mPerformance = aOwner->GetPerformance(); +} + +PerformanceObserver::PerformanceObserver(WorkerPrivate* aWorkerPrivate, + PerformanceObserverCallback& aCb) + : mCallback(&aCb), mObserverType(ObserverTypeUndefined), mConnected(false) { + MOZ_ASSERT(aWorkerPrivate); + mPerformance = aWorkerPrivate->GlobalScope()->GetPerformance(); +} + +PerformanceObserver::~PerformanceObserver() { + Disconnect(); + MOZ_ASSERT(!mConnected); +} + +// static +already_AddRefed<PerformanceObserver> PerformanceObserver::Constructor( + const GlobalObject& aGlobal, PerformanceObserverCallback& aCb, + ErrorResult& aRv) { + if (NS_IsMainThread()) { + nsCOMPtr<nsPIDOMWindowInner> ownerWindow = + do_QueryInterface(aGlobal.GetAsSupports()); + if (!ownerWindow) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + RefPtr<PerformanceObserver> observer = + new PerformanceObserver(ownerWindow, aCb); + return observer.forget(); + } + + JSContext* cx = aGlobal.Context(); + WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx); + MOZ_ASSERT(workerPrivate); + + RefPtr<PerformanceObserver> observer = + new PerformanceObserver(workerPrivate, aCb); + return observer.forget(); +} + +JSObject* PerformanceObserver::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return PerformanceObserver_Binding::Wrap(aCx, this, aGivenProto); +} + +void PerformanceObserver::Notify() { + if (mQueuedEntries.IsEmpty()) { + return; + } + RefPtr<PerformanceObserverEntryList> list = + new PerformanceObserverEntryList(this, mQueuedEntries); + + mQueuedEntries.Clear(); + + ErrorResult rv; + RefPtr<PerformanceObserverCallback> callback(mCallback); + callback->Call(this, *list, *this, rv); + if (NS_WARN_IF(rv.Failed())) { + rv.SuppressException(); + } +} + +void PerformanceObserver::QueueEntry(PerformanceEntry* aEntry) { + MOZ_ASSERT(aEntry); + MOZ_ASSERT(ObservesTypeOfEntry(aEntry)); + + mQueuedEntries.AppendElement(aEntry); +} + +static constexpr nsLiteralString kValidEventTimingNames[2] = { + u"event"_ns, u"first-input"_ns}; + +/* + * Keep this list in alphabetical order. + * https://w3c.github.io/performance-timeline/#supportedentrytypes-attribute + */ +static constexpr nsLiteralString kValidTypeNames[5] = { + u"mark"_ns, u"measure"_ns, u"navigation"_ns, u"paint"_ns, u"resource"_ns, +}; + +void PerformanceObserver::ReportUnsupportedTypesErrorToConsole( + bool aIsMainThread, const char* msgId, const nsString& aInvalidTypes) { + if (!aIsMainThread) { + nsTArray<nsString> params; + params.AppendElement(aInvalidTypes); + WorkerPrivate::ReportErrorToConsole(msgId, params); + } else { + nsCOMPtr<nsPIDOMWindowInner> ownerWindow = do_QueryInterface(mOwner); + Document* document = ownerWindow->GetExtantDoc(); + AutoTArray<nsString, 1> params = {aInvalidTypes}; + nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, "DOM"_ns, + document, nsContentUtils::eDOM_PROPERTIES, + msgId, params); + } +} + +void PerformanceObserver::Observe(const PerformanceObserverInit& aOptions, + ErrorResult& aRv) { + const Optional<Sequence<nsString>>& maybeEntryTypes = aOptions.mEntryTypes; + const Optional<nsString>& maybeType = aOptions.mType; + const Optional<bool>& maybeBuffered = aOptions.mBuffered; + + if (!mPerformance) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + if (!maybeEntryTypes.WasPassed() && !maybeType.WasPassed()) { + /* Per spec (3.3.1.2), this should be a syntax error. */ + aRv.ThrowTypeError("Can't call observe without `type` or `entryTypes`"); + return; + } + + if (maybeEntryTypes.WasPassed() && + (maybeType.WasPassed() || maybeBuffered.WasPassed())) { + /* Per spec (3.3.1.3), this, too, should be a syntax error. */ + aRv.ThrowTypeError("Can't call observe with both `type` and `entryTypes`"); + return; + } + + /* 3.3.1.4.1 */ + if (mObserverType == ObserverTypeUndefined) { + if (maybeEntryTypes.WasPassed()) { + mObserverType = ObserverTypeMultiple; + } else { + mObserverType = ObserverTypeSingle; + } + } + + /* 3.3.1.4.2 */ + if (mObserverType == ObserverTypeSingle && maybeEntryTypes.WasPassed()) { + aRv.Throw(NS_ERROR_DOM_INVALID_MODIFICATION_ERR); + return; + } + /* 3.3.1.4.3 */ + if (mObserverType == ObserverTypeMultiple && maybeType.WasPassed()) { + aRv.Throw(NS_ERROR_DOM_INVALID_MODIFICATION_ERR); + return; + } + + bool needQueueNotificationObserverTask = false; + /* 3.3.1.5 */ + if (mObserverType == ObserverTypeMultiple) { + const Sequence<nsString>& entryTypes = maybeEntryTypes.Value(); + + if (entryTypes.IsEmpty()) { + return; + } + + /* 3.3.1.5.2 */ + nsTArray<nsString> validEntryTypes; + + if (StaticPrefs::dom_enable_event_timing()) { + for (const nsLiteralString& name : kValidEventTimingNames) { + if (entryTypes.Contains(name) && !validEntryTypes.Contains(name)) { + validEntryTypes.AppendElement(name); + } + } + } + if (StaticPrefs::dom_enable_largest_contentful_paint()) { + if (entryTypes.Contains(kLargestContentfulPaintName) && + !validEntryTypes.Contains(kLargestContentfulPaintName)) { + validEntryTypes.AppendElement(kLargestContentfulPaintName); + } + } + for (const nsLiteralString& name : kValidTypeNames) { + if (entryTypes.Contains(name) && !validEntryTypes.Contains(name)) { + validEntryTypes.AppendElement(name); + } + } + + nsAutoString invalidTypesJoined; + bool addComma = false; + for (const auto& type : entryTypes) { + if (!validEntryTypes.Contains<nsString>(type)) { + if (addComma) { + invalidTypesJoined.AppendLiteral(", "); + } + addComma = true; + invalidTypesJoined.Append(type); + } + } + + if (!invalidTypesJoined.IsEmpty()) { + ReportUnsupportedTypesErrorToConsole(NS_IsMainThread(), + UnsupportedEntryTypesIgnoredMsgId, + invalidTypesJoined); + } + + /* 3.3.1.5.3 */ + if (validEntryTypes.IsEmpty()) { + nsString errorString; + ReportUnsupportedTypesErrorToConsole( + NS_IsMainThread(), AllEntryTypesIgnoredMsgId, errorString); + return; + } + + /* + * Registered or not, we clear out the list of options, and start fresh + * with the one that we are using here. (3.3.1.5.4,5) + */ + mOptions.Clear(); + mOptions.AppendElement(aOptions); + + } else { + MOZ_ASSERT(mObserverType == ObserverTypeSingle); + bool typeValid = false; + nsString type = maybeType.Value(); + + /* 3.3.1.6.2 */ + if (StaticPrefs::dom_enable_event_timing()) { + for (const nsLiteralString& name : kValidEventTimingNames) { + if (type == name) { + typeValid = true; + break; + } + } + } + for (const nsLiteralString& name : kValidTypeNames) { + if (type == name) { + typeValid = true; + break; + } + } + + if (StaticPrefs::dom_enable_largest_contentful_paint()) { + if (type == kLargestContentfulPaintName) { + typeValid = true; + } + } + + if (!typeValid) { + ReportUnsupportedTypesErrorToConsole( + NS_IsMainThread(), UnsupportedEntryTypesIgnoredMsgId, type); + return; + } + + /* 3.3.1.6.4, 3.3.1.6.4 */ + bool didUpdateOptionsList = false; + nsTArray<PerformanceObserverInit> updatedOptionsList; + for (auto& option : mOptions) { + if (option.mType.WasPassed() && option.mType.Value() == type) { + updatedOptionsList.AppendElement(aOptions); + didUpdateOptionsList = true; + } else { + updatedOptionsList.AppendElement(option); + } + } + if (!didUpdateOptionsList) { + updatedOptionsList.AppendElement(aOptions); + } + mOptions = std::move(updatedOptionsList); + + /* 3.3.1.6.5 */ + if (maybeBuffered.WasPassed() && maybeBuffered.Value()) { + nsTArray<RefPtr<PerformanceEntry>> existingEntries; + mPerformance->GetEntriesByTypeForObserver(type, existingEntries); + if (!existingEntries.IsEmpty()) { + mQueuedEntries.AppendElements(existingEntries); + needQueueNotificationObserverTask = true; + } + } + } + /* Add ourselves to the list of registered performance + * observers, if necessary. (3.3.1.5.4,5; 3.3.1.6.4) + */ + mPerformance->AddObserver(this); + + if (needQueueNotificationObserverTask) { + mPerformance->QueueNotificationObserversTask(); + } + mConnected = true; +} + +void PerformanceObserver::GetSupportedEntryTypes( + const GlobalObject& aGlobal, JS::MutableHandle<JSObject*> aObject) { + nsTArray<nsString> validTypes; + JS::Rooted<JS::Value> val(aGlobal.Context()); + + if (StaticPrefs::dom_enable_event_timing()) { + for (const nsLiteralString& name : kValidEventTimingNames) { + validTypes.AppendElement(name); + } + } + + if (StaticPrefs::dom_enable_largest_contentful_paint()) { + validTypes.AppendElement(u"largest-contentful-paint"_ns); + } + for (const nsLiteralString& name : kValidTypeNames) { + validTypes.AppendElement(name); + } + + if (!ToJSValue(aGlobal.Context(), validTypes, &val)) { + /* + * If this conversion fails, we don't set a result. + * The spec does not allow us to throw an exception. + */ + return; + } + aObject.set(&val.toObject()); +} + +bool PerformanceObserver::ObservesTypeOfEntry(PerformanceEntry* aEntry) { + for (auto& option : mOptions) { + if (aEntry->ShouldAddEntryToObserverBuffer(option)) { + return true; + } + } + return false; +} + +void PerformanceObserver::Disconnect() { + if (mConnected) { + MOZ_ASSERT(mPerformance); + mPerformance->RemoveObserver(this); + mOptions.Clear(); + mConnected = false; + } +} + +void PerformanceObserver::TakeRecords( + nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + MOZ_ASSERT(aRetval.IsEmpty()); + aRetval = std::move(mQueuedEntries); +} diff --git a/dom/performance/PerformanceObserver.h b/dom/performance/PerformanceObserver.h new file mode 100644 index 0000000000..7b50eb8b60 --- /dev/null +++ b/dom/performance/PerformanceObserver.h @@ -0,0 +1,91 @@ +/* -*- 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_PerformanceObserver_h__ +#define mozilla_dom_PerformanceObserver_h__ + +#include "nsCOMPtr.h" +#include "nsISupports.h" +#include "mozilla/dom/PerformanceObserverBinding.h" +#include "mozilla/RefPtr.h" +#include "nsString.h" +#include "nsTArray.h" +#include "nsWrapperCache.h" + +class nsPIDOMWindowInner; + +namespace mozilla { + +class ErrorResult; + +namespace dom { + +class GlobalObject; +class Performance; +class PerformanceEntry; +class PerformanceObserverCallback; +class WorkerPrivate; + +class PerformanceObserver final : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PerformanceObserver) + + static already_AddRefed<PerformanceObserver> Constructor( + const GlobalObject& aGlobal, PerformanceObserverCallback& aCb, + ErrorResult& aRv); + + PerformanceObserver(nsPIDOMWindowInner* aOwner, + PerformanceObserverCallback& aCb); + + PerformanceObserver(WorkerPrivate* aWorkerPrivate, + PerformanceObserverCallback& aCb); + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + nsISupports* GetParentObject() const { return mOwner; } + + void Observe(const PerformanceObserverInit& aOptions, ErrorResult& aRv); + static void GetSupportedEntryTypes(const GlobalObject& aGlobal, + JS::MutableHandle<JSObject*> aObject); + + void Disconnect(); + + void TakeRecords(nsTArray<RefPtr<PerformanceEntry>>& aRetval); + + MOZ_CAN_RUN_SCRIPT void Notify(); + void QueueEntry(PerformanceEntry* aEntry); + + bool ObservesTypeOfEntry(PerformanceEntry* aEntry); + + private: + void ReportUnsupportedTypesErrorToConsole(bool aIsMainThread, + const char* msgId, + const nsString& aInvalidTypes); + ~PerformanceObserver(); + + nsCOMPtr<nsISupports> mOwner; + RefPtr<PerformanceObserverCallback> mCallback; + RefPtr<Performance> mPerformance; + nsTArray<nsString> mEntryTypes; + nsTArray<PerformanceObserverInit> mOptions; + enum { + ObserverTypeUndefined, + ObserverTypeSingle, + ObserverTypeMultiple, + } mObserverType; + /* + * This is also known as registered, in the spec. + */ + bool mConnected; + nsTArray<RefPtr<PerformanceEntry>> mQueuedEntries; +}; + +} // namespace dom +} // namespace mozilla + +#endif diff --git a/dom/performance/PerformanceObserverEntryList.cpp b/dom/performance/PerformanceObserverEntryList.cpp new file mode 100644 index 0000000000..af4d867cd7 --- /dev/null +++ b/dom/performance/PerformanceObserverEntryList.cpp @@ -0,0 +1,100 @@ +/* -*- 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 "PerformanceObserverEntryList.h" + +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/PerformanceObserverEntryListBinding.h" +#include "nsString.h" +#include "PerformanceResourceTiming.h" + +using namespace mozilla; +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PerformanceObserverEntryList, mOwner, + mEntries) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(PerformanceObserverEntryList) +NS_IMPL_CYCLE_COLLECTING_RELEASE(PerformanceObserverEntryList) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceObserverEntryList) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +PerformanceObserverEntryList::~PerformanceObserverEntryList() = default; + +JSObject* PerformanceObserverEntryList::WrapObject( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return PerformanceObserverEntryList_Binding::Wrap(aCx, this, aGivenProto); +} + +void PerformanceObserverEntryList::GetEntries( + const PerformanceEntryFilterOptions& aFilter, + nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + aRetval.Clear(); + RefPtr<nsAtom> name = + aFilter.mName.WasPassed() ? NS_Atomize(aFilter.mName.Value()) : nullptr; + RefPtr<nsAtom> entryType = aFilter.mEntryType.WasPassed() + ? NS_Atomize(aFilter.mEntryType.Value()) + : nullptr; + for (const RefPtr<PerformanceEntry>& entry : mEntries) { + if (aFilter.mInitiatorType.WasPassed()) { + const PerformanceResourceTiming* resourceEntry = + entry->ToResourceTiming(); + if (!resourceEntry) { + continue; + } + nsAutoString initiatorType; + resourceEntry->GetInitiatorType(initiatorType); + if (!initiatorType.Equals(aFilter.mInitiatorType.Value())) { + continue; + } + } + if (name && entry->GetName() != name) { + continue; + } + if (entryType && entry->GetEntryType() != entryType) { + continue; + } + + aRetval.AppendElement(entry); + } + aRetval.Sort(PerformanceEntryComparator()); +} + +void PerformanceObserverEntryList::GetEntriesByType( + const nsAString& aEntryType, nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + aRetval.Clear(); + RefPtr<nsAtom> entryType = NS_Atomize(aEntryType); + for (const RefPtr<PerformanceEntry>& entry : mEntries) { + if (entry->GetEntryType() == entryType) { + aRetval.AppendElement(entry); + } + } + aRetval.Sort(PerformanceEntryComparator()); +} + +void PerformanceObserverEntryList::GetEntriesByName( + const nsAString& aName, const Optional<nsAString>& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& aRetval) { + aRetval.Clear(); + RefPtr<nsAtom> name = NS_Atomize(aName); + RefPtr<nsAtom> entryType = + aEntryType.WasPassed() ? NS_Atomize(aEntryType.Value()) : nullptr; + for (const RefPtr<PerformanceEntry>& entry : mEntries) { + if (entry->GetName() != name) { + continue; + } + + if (entryType && entry->GetEntryType() != entryType) { + continue; + } + + aRetval.AppendElement(entry); + } + aRetval.Sort(PerformanceEntryComparator()); +} diff --git a/dom/performance/PerformanceObserverEntryList.h b/dom/performance/PerformanceObserverEntryList.h new file mode 100644 index 0000000000..3a353060da --- /dev/null +++ b/dom/performance/PerformanceObserverEntryList.h @@ -0,0 +1,55 @@ +/* -*- 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_PerformanceObserverEntryList_h__ +#define mozilla_dom_PerformanceObserverEntryList_h__ + +#include "nsCOMPtr.h" +#include "nsISupports.h" +#include "nsTArray.h" +#include "nsWrapperCache.h" +#include "mozilla/dom/PerformanceEntryBinding.h" + +namespace mozilla::dom { + +struct PerformanceEntryFilterOptions; +class PerformanceEntry; +template <typename T> +class Optional; + +class PerformanceObserverEntryList final : public nsISupports, + public nsWrapperCache { + ~PerformanceObserverEntryList(); + + public: + PerformanceObserverEntryList( + nsISupports* aOwner, const nsTArray<RefPtr<PerformanceEntry>>& aEntries) + : mOwner(aOwner), mEntries(aEntries.Clone()) {} + + nsISupports* GetParentObject() const { return mOwner; } + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PerformanceObserverEntryList) + + void GetEntries(const PerformanceEntryFilterOptions& aFilter, + nsTArray<RefPtr<PerformanceEntry>>& aRetval); + void GetEntriesByType(const nsAString& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& aRetval); + void GetEntriesByName(const nsAString& aName, + const Optional<nsAString>& aEntryType, + nsTArray<RefPtr<PerformanceEntry>>& aRetval); + + private: + nsCOMPtr<nsISupports> mOwner; + nsTArray<RefPtr<PerformanceEntry>> mEntries; +}; + +} // namespace mozilla::dom + +#endif diff --git a/dom/performance/PerformancePaintTiming.cpp b/dom/performance/PerformancePaintTiming.cpp new file mode 100644 index 0000000000..83eed06565 --- /dev/null +++ b/dom/performance/PerformancePaintTiming.cpp @@ -0,0 +1,52 @@ +/* -*- 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 "PerformancePaintTiming.h" +#include "Performance.h" +#include "MainThreadUtils.h" +#include "mozilla/dom/PerformanceMeasureBinding.h" +#include "nsRFPService.h" + +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTION_INHERITED(PerformancePaintTiming, PerformanceEntry, + mPerformance) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformancePaintTiming) +NS_INTERFACE_MAP_END_INHERITING(PerformanceEntry) + +NS_IMPL_ADDREF_INHERITED(PerformancePaintTiming, PerformanceEntry) +NS_IMPL_RELEASE_INHERITED(PerformancePaintTiming, PerformanceEntry) + +PerformancePaintTiming::PerformancePaintTiming(Performance* aPerformance, + const nsAString& aName, + const TimeStamp& aStartTime) + : PerformanceEntry(aPerformance->GetParentObject(), aName, u"paint"_ns), + mPerformance(aPerformance), + mRawStartTime(aStartTime) {} + +PerformancePaintTiming::~PerformancePaintTiming() = default; + +JSObject* PerformancePaintTiming::WrapObject( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return PerformancePaintTiming_Binding::Wrap(aCx, this, aGivenProto); +} + +DOMHighResTimeStamp PerformancePaintTiming::StartTime() const { + if (mCachedStartTime.isNothing()) { + DOMHighResTimeStamp rawValue = + mPerformance->GetDOMTiming()->TimeStampToDOMHighRes(mRawStartTime); + mCachedStartTime.emplace(nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType())); + } + return mCachedStartTime.value(); +} + +size_t PerformancePaintTiming::SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} diff --git a/dom/performance/PerformancePaintTiming.h b/dom/performance/PerformancePaintTiming.h new file mode 100644 index 0000000000..395866dbc2 --- /dev/null +++ b/dom/performance/PerformancePaintTiming.h @@ -0,0 +1,50 @@ +/* -*- 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_PerformancePaintTiming_h___ +#define mozilla_dom_PerformancePaintTiming_h___ + +#include "mozilla/dom/PerformanceEntry.h" +#include "mozilla/dom/PerformancePaintTimingBinding.h" + +namespace mozilla::dom { + +class Performance; + +// https://w3c.github.io/paint-timing/#sec-PerformancePaintTiming +// Unlike timeToContentfulPaint, this timing is generated during +// displaylist building, when a frame is contentful, we collect +// the timestamp. Whereas, timeToContentfulPaint uses a compositor-side +// timestamp. +class PerformancePaintTiming final : public PerformanceEntry { + public: + PerformancePaintTiming(Performance* aPerformance, const nsAString& aName, + const TimeStamp& aStartTime); + + NS_DECL_ISUPPORTS_INHERITED + + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PerformancePaintTiming, + PerformanceEntry) + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + DOMHighResTimeStamp StartTime() const override; + + size_t SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const override; + + private: + ~PerformancePaintTiming(); + RefPtr<Performance> mPerformance; + + const TimeStamp mRawStartTime; + mutable Maybe<DOMHighResTimeStamp> mCachedStartTime; +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_PerformanacePaintTiming_h___ */ diff --git a/dom/performance/PerformanceResourceTiming.cpp b/dom/performance/PerformanceResourceTiming.cpp new file mode 100644 index 0000000000..cfb91b2980 --- /dev/null +++ b/dom/performance/PerformanceResourceTiming.cpp @@ -0,0 +1,133 @@ +/* -*- 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 "PerformanceResourceTiming.h" +#include "mozilla/dom/PerformanceResourceTimingBinding.h" +#include "nsNetUtil.h" +#include "nsArrayUtils.h" + +using namespace mozilla::dom; + +NS_IMPL_CYCLE_COLLECTION_INHERITED(PerformanceResourceTiming, PerformanceEntry, + mPerformance) + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(PerformanceResourceTiming, + PerformanceEntry) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceResourceTiming) +NS_INTERFACE_MAP_END_INHERITING(PerformanceEntry) + +NS_IMPL_ADDREF_INHERITED(PerformanceResourceTiming, PerformanceEntry) +NS_IMPL_RELEASE_INHERITED(PerformanceResourceTiming, PerformanceEntry) + +PerformanceResourceTiming::PerformanceResourceTiming( + UniquePtr<PerformanceTimingData>&& aPerformanceTiming, + Performance* aPerformance, const nsAString& aName) + : PerformanceEntry(aPerformance->GetParentObject(), aName, u"resource"_ns), + mTimingData(std::move(aPerformanceTiming)), + mPerformance(aPerformance) { + MOZ_RELEASE_ASSERT(mTimingData); + MOZ_ASSERT(aPerformance, "Parent performance object should be provided"); + if (NS_IsMainThread()) { + // Used to check if an addon content script has access to this timing. + // We don't need it in workers, and ignore mOriginalURI if null. + NS_NewURI(getter_AddRefs(mOriginalURI), aName); + } +} + +PerformanceResourceTiming::~PerformanceResourceTiming() = default; + +DOMHighResTimeStamp PerformanceResourceTiming::FetchStart() const { + if (mTimingData->TimingAllowed()) { + return mTimingData->FetchStartHighRes(mPerformance); + } + return StartTime(); +} + +DOMHighResTimeStamp PerformanceResourceTiming::StartTime() const { + // Force the start time to be the earliest of: + // - RedirectStart + // - WorkerStart + // - AsyncOpen + // Ignore zero values. The RedirectStart and WorkerStart values + // can come from earlier redirected channels prior to the AsyncOpen + // time being recorded. + if (mCachedStartTime.isNothing()) { + DOMHighResTimeStamp redirect = + mTimingData->RedirectStartHighRes(mPerformance); + redirect = redirect ? redirect : DBL_MAX; + + DOMHighResTimeStamp worker = mTimingData->WorkerStartHighRes(mPerformance); + worker = worker ? worker : DBL_MAX; + + DOMHighResTimeStamp asyncOpen = mTimingData->AsyncOpenHighRes(mPerformance); + + mCachedStartTime.emplace(std::min(asyncOpen, std::min(redirect, worker))); + } + return mCachedStartTime.value(); +} + +JSObject* PerformanceResourceTiming::WrapObject( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return PerformanceResourceTiming_Binding::Wrap(aCx, this, aGivenProto); +} + +size_t PerformanceResourceTiming::SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} + +size_t PerformanceResourceTiming::SizeOfExcludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const { + return PerformanceEntry::SizeOfExcludingThis(aMallocSizeOf) + + mInitiatorType.SizeOfExcludingThisIfUnshared(aMallocSizeOf) + + mTimingData->NextHopProtocol().SizeOfExcludingThisIfUnshared( + aMallocSizeOf); +} + +void PerformanceResourceTiming::GetServerTiming( + nsTArray<RefPtr<PerformanceServerTiming>>& aRetval, + nsIPrincipal& aSubjectPrincipal) { + aRetval.Clear(); + if (!TimingAllowedForCaller(aSubjectPrincipal)) { + return; + } + + nsTArray<nsCOMPtr<nsIServerTiming>> serverTimingArray = + mTimingData->GetServerTiming(); + uint32_t length = serverTimingArray.Length(); + for (uint32_t index = 0; index < length; ++index) { + nsCOMPtr<nsIServerTiming> serverTiming = serverTimingArray.ElementAt(index); + MOZ_ASSERT(serverTiming); + + aRetval.AppendElement( + new PerformanceServerTiming(GetParentObject(), serverTiming)); + } +} + +bool PerformanceResourceTiming::TimingAllowedForCaller( + nsIPrincipal& aCaller) const { + if (mTimingData->TimingAllowed()) { + return true; + } + + // Check if the addon has permission to access the cross-origin resource. + return mOriginalURI && + BasePrincipal::Cast(&aCaller)->AddonAllowsLoad(mOriginalURI); +} + +bool PerformanceResourceTiming::ReportRedirectForCaller( + nsIPrincipal& aCaller, bool aEnsureSameOriginAndIgnoreTAO) const { + if (mTimingData->ShouldReportCrossOriginRedirect( + aEnsureSameOriginAndIgnoreTAO)) { + return true; + } + + // Only report cross-origin redirect if the addon has <all_urls> permission. + return BasePrincipal::Cast(&aCaller)->AddonHasPermission( + nsGkAtoms::all_urlsPermission); +} diff --git a/dom/performance/PerformanceResourceTiming.h b/dom/performance/PerformanceResourceTiming.h new file mode 100644 index 0000000000..baa5953d2d --- /dev/null +++ b/dom/performance/PerformanceResourceTiming.h @@ -0,0 +1,172 @@ +/* -*- 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_PerformanceResourceTiming_h___ +#define mozilla_dom_PerformanceResourceTiming_h___ + +#include "mozilla/UniquePtr.h" +#include "nsCOMPtr.h" +#include "Performance.h" +#include "PerformanceEntry.h" +#include "PerformanceServerTiming.h" +#include "PerformanceTiming.h" + +namespace mozilla::dom { +#define IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(name) \ + DOMHighResTimeStamp name(nsIPrincipal& aSubjectPrincipal) const { \ + bool allowed = !mTimingData->RedirectCountReal() \ + ? TimingAllowedForCaller(aSubjectPrincipal) \ + : ReportRedirectForCaller(aSubjectPrincipal, false); \ + return allowed ? mTimingData->name##HighRes(mPerformance) : 0; \ + } + +#define IMPL_RESOURCE_TIMING_TAO_PROTECTED_SIZE_PROP(name) \ + uint64_t name(nsIPrincipal& aSubjectPrincipal) const { \ + bool allowed = !mTimingData->RedirectCountReal() \ + ? TimingAllowedForCaller(aSubjectPrincipal) \ + : ReportRedirectForCaller(aSubjectPrincipal, false); \ + return allowed ? mTimingData->name() : 0; \ + } + +// http://www.w3.org/TR/resource-timing/#performanceresourcetiming +class PerformanceResourceTiming : public PerformanceEntry { + public: + using TimeStamp = mozilla::TimeStamp; + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED( + PerformanceResourceTiming, PerformanceEntry) + + // aPerformanceTimingData and aPerformance must be non-null + PerformanceResourceTiming( + UniquePtr<PerformanceTimingData>&& aPerformanceTimingData, + Performance* aPerformance, const nsAString& aName); + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + virtual DOMHighResTimeStamp StartTime() const override; + + virtual DOMHighResTimeStamp Duration() const override { + return ResponseEnd() - StartTime(); + } + + void GetInitiatorType(nsAString& aInitiatorType) const { + aInitiatorType = mInitiatorType; + } + + void SetInitiatorType(const nsAString& aInitiatorType) { + mInitiatorType = aInitiatorType; + } + + void GetNextHopProtocol(nsAString& aNextHopProtocol) const { + if (mTimingData->TimingAllowed()) { + aNextHopProtocol = mTimingData->NextHopProtocol(); + } + } + + DOMHighResTimeStamp WorkerStart() const { + return mTimingData->WorkerStartHighRes(mPerformance); + } + + DOMHighResTimeStamp FetchStart() const; + + DOMHighResTimeStamp RedirectStart(nsIPrincipal& aSubjectPrincipal, + bool aEnsureSameOriginAndIgnoreTAO) const { + // We have to check if all the redirect URIs whether had the same origin or + // different origins with TAO headers set (since there is no check in + // RedirectStartHighRes()) + return ReportRedirectForCaller(aSubjectPrincipal, + aEnsureSameOriginAndIgnoreTAO) + ? mTimingData->RedirectStartHighRes(mPerformance) + : 0; + } + + virtual DOMHighResTimeStamp RedirectStart( + nsIPrincipal& aSubjectPrincipal) const { + return RedirectStart(aSubjectPrincipal, + false /* aEnsureSameOriginAndIgnoreTAO */); + } + + DOMHighResTimeStamp RedirectEnd(nsIPrincipal& aSubjectPrincipal, + bool aEnsureSameOriginAndIgnoreTAO) const { + // We have to check if all the redirect URIs whether had the same origin or + // different origins with TAO headers set (since there is no check in + // RedirectEndHighRes()) + return ReportRedirectForCaller(aSubjectPrincipal, + aEnsureSameOriginAndIgnoreTAO) + ? mTimingData->RedirectEndHighRes(mPerformance) + : 0; + } + + virtual DOMHighResTimeStamp RedirectEnd( + nsIPrincipal& aSubjectPrincipal) const { + return RedirectEnd(aSubjectPrincipal, + false /* aEnsureSameOriginAndIgnoreTAO */); + } + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(DomainLookupStart) + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(DomainLookupEnd) + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(ConnectStart) + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(ConnectEnd) + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(RequestStart) + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(ResponseStart) + + DOMHighResTimeStamp ResponseEnd() const { + return mTimingData->ResponseEndHighRes(mPerformance); + } + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_TIMING_PROP(SecureConnectionStart) + + virtual const PerformanceResourceTiming* ToResourceTiming() const override { + return this; + } + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_SIZE_PROP(TransferSize) + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_SIZE_PROP(EncodedBodySize) + + IMPL_RESOURCE_TIMING_TAO_PROTECTED_SIZE_PROP(DecodedBodySize) + + void GetServerTiming(nsTArray<RefPtr<PerformanceServerTiming>>& aRetval, + nsIPrincipal& aSubjectPrincipal); + + size_t SizeOfIncludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const override; + + protected: + virtual ~PerformanceResourceTiming(); + + size_t SizeOfExcludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const override; + + // Check if caller has access to cross-origin timings, either by the rules + // from the spec, or based on addon permissions. + bool TimingAllowedForCaller(nsIPrincipal& aCaller) const; + + // Check if cross-origin redirects should be reported to the caller. + bool ReportRedirectForCaller(nsIPrincipal& aCaller, + bool aEnsureSameOriginAndIgnoreTAO) const; + + nsString mInitiatorType; + const UniquePtr<PerformanceTimingData> mTimingData; // always non-null + RefPtr<Performance> mPerformance; + + // The same initial requested URI as the `name` attribute. + nsCOMPtr<nsIURI> mOriginalURI; + + private: + mutable Maybe<DOMHighResTimeStamp> mCachedStartTime; +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_PerformanceResourceTiming_h___ */ diff --git a/dom/performance/PerformanceServerTiming.cpp b/dom/performance/PerformanceServerTiming.cpp new file mode 100644 index 0000000000..e5f056652d --- /dev/null +++ b/dom/performance/PerformanceServerTiming.cpp @@ -0,0 +1,71 @@ +/* -*- 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 "PerformanceServerTiming.h" +#include "nsITimedChannel.h" + +#include "mozilla/dom/PerformanceServerTimingBinding.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PerformanceServerTiming, mParent) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(PerformanceServerTiming) +NS_IMPL_CYCLE_COLLECTING_RELEASE(PerformanceServerTiming) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PerformanceServerTiming) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +JSObject* PerformanceServerTiming::WrapObject( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return mozilla::dom::PerformanceServerTiming_Binding::Wrap(aCx, this, + aGivenProto); +} + +void PerformanceServerTiming::GetName(nsAString& aName) const { + aName.Truncate(); + + if (!mServerTiming) { + return; + } + + nsAutoCString name; + if (NS_WARN_IF(NS_FAILED(mServerTiming->GetName(name)))) { + return; + } + + aName.Assign(NS_ConvertUTF8toUTF16(name)); +} + +DOMHighResTimeStamp PerformanceServerTiming::Duration() const { + if (!mServerTiming) { + return 0; + } + + double duration = 0; + if (NS_WARN_IF(NS_FAILED(mServerTiming->GetDuration(&duration)))) { + return 0; + } + + return duration; +} + +void PerformanceServerTiming::GetDescription(nsAString& aDescription) const { + if (!mServerTiming) { + return; + } + + nsAutoCString description; + if (NS_WARN_IF(NS_FAILED(mServerTiming->GetDescription(description)))) { + return; + } + + aDescription.Assign(NS_ConvertUTF8toUTF16(description)); +} + +} // namespace mozilla::dom diff --git a/dom/performance/PerformanceServerTiming.h b/dom/performance/PerformanceServerTiming.h new file mode 100644 index 0000000000..27b85d29fd --- /dev/null +++ b/dom/performance/PerformanceServerTiming.h @@ -0,0 +1,52 @@ +/* -*- 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_PerformanceServerTiming_h +#define mozilla_dom_PerformanceServerTiming_h + +#include "mozilla/Attributes.h" +#include "nsCOMPtr.h" +#include "nsDOMNavigationTiming.h" +#include "nsWrapperCache.h" +#include "nsString.h" + +class nsIServerTiming; +class nsISupports; + +namespace mozilla::dom { + +class PerformanceServerTiming final : public nsISupports, + public nsWrapperCache { + public: + PerformanceServerTiming(nsISupports* aParent, nsIServerTiming* aServerTiming) + : mParent(aParent), mServerTiming(aServerTiming) { + MOZ_ASSERT(mServerTiming); + } + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PerformanceServerTiming) + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + nsISupports* GetParentObject() const { return mParent; } + + void GetName(nsAString& aName) const; + + DOMHighResTimeStamp Duration() const; + + void GetDescription(nsAString& aDescription) const; + + private: + ~PerformanceServerTiming() = default; + + nsCOMPtr<nsISupports> mParent; + nsCOMPtr<nsIServerTiming> mServerTiming; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceServerTiming_h diff --git a/dom/performance/PerformanceService.cpp b/dom/performance/PerformanceService.cpp new file mode 100644 index 0000000000..746d278b77 --- /dev/null +++ b/dom/performance/PerformanceService.cpp @@ -0,0 +1,42 @@ +/* -*- 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 "PerformanceService.h" + +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/StaticMutex.h" +#include "mozilla/StaticPtr.h" +#include "prtime.h" + +namespace mozilla::dom { + +static StaticRefPtr<PerformanceService> gPerformanceService; +static StaticMutex gPerformanceServiceMutex MOZ_UNANNOTATED; + +/* static */ +PerformanceService* PerformanceService::GetOrCreate() { + StaticMutexAutoLock al(gPerformanceServiceMutex); + + if (!gPerformanceService) { + gPerformanceService = new PerformanceService(); + ClearOnShutdown(&gPerformanceService); + } + + return gPerformanceService; +} + +DOMHighResTimeStamp PerformanceService::TimeOrigin( + const TimeStamp& aCreationTimeStamp) const { + return (aCreationTimeStamp - mCreationTimeStamp).ToMilliseconds() + + (mCreationEpochTime / PR_USEC_PER_MSEC); +} + +PerformanceService::PerformanceService() { + mCreationTimeStamp = TimeStamp::Now(); + mCreationEpochTime = PR_Now(); +} + +} // namespace mozilla::dom diff --git a/dom/performance/PerformanceService.h b/dom/performance/PerformanceService.h new file mode 100644 index 0000000000..80ded9b180 --- /dev/null +++ b/dom/performance/PerformanceService.h @@ -0,0 +1,43 @@ +/* -*- 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 dom_performance_PerformanceService_h +#define dom_performance_PerformanceService_h + +#include "mozilla/TimeStamp.h" +#include "nsCOMPtr.h" +#include "nsDOMNavigationTiming.h" + +namespace mozilla::dom { + +// This class is thread-safe. + +// We use this singleton for having the correct value of performance.timeOrigin. +// This value must be calculated on top of the pair: +// - mCreationTimeStamp (monotonic clock) +// - mCreationEpochTime (unix epoch time) +// These 2 values must be taken "at the same time" in order to be used +// correctly. + +class PerformanceService { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PerformanceService) + + static PerformanceService* GetOrCreate(); + + DOMHighResTimeStamp TimeOrigin(const TimeStamp& aCreationTimeStamp) const; + + private: + PerformanceService(); + ~PerformanceService() = default; + + TimeStamp mCreationTimeStamp; + PRTime mCreationEpochTime; +}; + +} // namespace mozilla::dom + +#endif // dom_performance_PerformanceService_h diff --git a/dom/performance/PerformanceStorage.h b/dom/performance/PerformanceStorage.h new file mode 100644 index 0000000000..b2eee47127 --- /dev/null +++ b/dom/performance/PerformanceStorage.h @@ -0,0 +1,35 @@ +/* -*- 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_PerformanceStorage_h +#define mozilla_dom_PerformanceStorage_h + +#include "nsISupportsImpl.h" + +class nsIHttpChannel; +class nsITimedChannel; + +namespace mozilla::dom { + +class PerformanceTimingData; + +class PerformanceStorage { + public: + NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING + + virtual void AddEntry(nsIHttpChannel* aChannel, + nsITimedChannel* aTimedChannel) = 0; + virtual void AddEntry(const nsString& entryName, + const nsString& initiatorType, + UniquePtr<PerformanceTimingData>&& aData) = 0; + + protected: + virtual ~PerformanceStorage() = default; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceStorage_h diff --git a/dom/performance/PerformanceStorageWorker.cpp b/dom/performance/PerformanceStorageWorker.cpp new file mode 100644 index 0000000000..4fb4815121 --- /dev/null +++ b/dom/performance/PerformanceStorageWorker.cpp @@ -0,0 +1,185 @@ +/* -*- 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 "PerformanceStorageWorker.h" +#include "Performance.h" +#include "PerformanceResourceTiming.h" +#include "PerformanceTiming.h" +#include "mozilla/dom/WorkerRef.h" +#include "mozilla/dom/WorkerRunnable.h" +#include "mozilla/dom/WorkerScope.h" + +namespace mozilla::dom { + +class PerformanceProxyData { + public: + PerformanceProxyData(UniquePtr<PerformanceTimingData>&& aData, + const nsAString& aInitiatorType, + const nsAString& aEntryName) + : mData(std::move(aData)), + mInitiatorType(aInitiatorType), + mEntryName(aEntryName) { + MOZ_RELEASE_ASSERT(mData); + } + + UniquePtr<PerformanceTimingData> mData; // always non-null + nsString mInitiatorType; + nsString mEntryName; +}; + +namespace { + +// Here we use control runnable because this code must be executed also when in +// a sync event loop +class PerformanceEntryAdder final : public WorkerControlRunnable { + public: + PerformanceEntryAdder(WorkerPrivate* aWorkerPrivate, + PerformanceStorageWorker* aStorage, + UniquePtr<PerformanceProxyData>&& aData) + : WorkerControlRunnable(aWorkerPrivate, "PerformanceEntryAdder", + WorkerThread), + mStorage(aStorage), + mData(std::move(aData)) {} + + bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override { + mStorage->AddEntryOnWorker(std::move(mData)); + return true; + } + + nsresult Cancel() override { + mStorage->ShutdownOnWorker(); + return NS_OK; + } + + bool PreDispatch(WorkerPrivate* aWorkerPrivate) override { return true; } + + void PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) override {} + + private: + RefPtr<PerformanceStorageWorker> mStorage; + UniquePtr<PerformanceProxyData> mData; +}; + +} // namespace + +/* static */ +already_AddRefed<PerformanceStorageWorker> PerformanceStorageWorker::Create( + WorkerPrivate* aWorkerPrivate) { + MOZ_ASSERT(aWorkerPrivate); + aWorkerPrivate->AssertIsOnWorkerThread(); + + RefPtr<PerformanceStorageWorker> storage = new PerformanceStorageWorker(); + + MutexAutoLock lock(storage->mMutex); // for thread-safety analysis + storage->mWorkerRef = WeakWorkerRef::Create( + aWorkerPrivate, [storage]() { storage->ShutdownOnWorker(); }); + + // PerformanceStorageWorker is created at the creation time of the worker. + MOZ_ASSERT(storage->mWorkerRef); + + return storage.forget(); +} + +PerformanceStorageWorker::PerformanceStorageWorker() + : mMutex("PerformanceStorageWorker::mMutex") {} + +PerformanceStorageWorker::~PerformanceStorageWorker() = default; + +void PerformanceStorageWorker::AddEntry(nsIHttpChannel* aChannel, + nsITimedChannel* aTimedChannel) { + MOZ_ASSERT(NS_IsMainThread()); + + MutexAutoLock lock(mMutex); + + if (!mWorkerRef) { + return; + } + + // If we have mWorkerRef, we haven't received the WorkerRef notification and + // we haven't yet call ShutdownOnWorker, which uses the mutex. + WorkerPrivate* workerPrivate = mWorkerRef->GetUnsafePrivate(); + MOZ_ASSERT(workerPrivate); + + nsAutoString initiatorType; + nsAutoString entryName; + + UniquePtr<PerformanceTimingData> performanceTimingData( + PerformanceTimingData::Create(aTimedChannel, aChannel, 0, initiatorType, + entryName)); + if (!performanceTimingData) { + return; + } + + UniquePtr<PerformanceProxyData> data(new PerformanceProxyData( + std::move(performanceTimingData), initiatorType, entryName)); + + RefPtr<PerformanceEntryAdder> r = + new PerformanceEntryAdder(workerPrivate, this, std::move(data)); + Unused << NS_WARN_IF(!r->Dispatch()); +} + +void PerformanceStorageWorker::AddEntry( + const nsString& aEntryName, const nsString& aInitiatorType, + UniquePtr<PerformanceTimingData>&& aData) { + MOZ_ASSERT(!NS_IsMainThread()); + if (!aData) { + return; + } + + UniquePtr<PerformanceProxyData> data = MakeUnique<PerformanceProxyData>( + std::move(aData), aInitiatorType, aEntryName); + + AddEntryOnWorker(std::move(data)); +} + +void PerformanceStorageWorker::ShutdownOnWorker() { + MutexAutoLock lock(mMutex); + + if (!mWorkerRef) { + return; + } + + MOZ_ASSERT(!NS_IsMainThread()); + + mWorkerRef = nullptr; +} + +void PerformanceStorageWorker::AddEntryOnWorker( + UniquePtr<PerformanceProxyData>&& aData) { + RefPtr<Performance> performance; + UniquePtr<PerformanceProxyData> data = std::move(aData); + + { + MutexAutoLock lock(mMutex); + + if (!mWorkerRef) { + return; + } + + // We must have the workerPrivate because it is available until a + // notification is received by WorkerRef and we use mutex to make the code + // protected. + WorkerPrivate* workerPrivate = mWorkerRef->GetPrivate(); + MOZ_ASSERT(workerPrivate); + + WorkerGlobalScope* scope = workerPrivate->GlobalScope(); + performance = scope->GetPerformance(); + } + + if (NS_WARN_IF(!performance)) { + return; + } + + RefPtr<PerformanceResourceTiming> performanceEntry = + new PerformanceResourceTiming(std::move(data->mData), performance, + data->mEntryName); + performanceEntry->SetInitiatorType(data->mInitiatorType); + + performance->InsertResourceEntry(performanceEntry); +} + +} // namespace mozilla::dom diff --git a/dom/performance/PerformanceStorageWorker.h b/dom/performance/PerformanceStorageWorker.h new file mode 100644 index 0000000000..e585069112 --- /dev/null +++ b/dom/performance/PerformanceStorageWorker.h @@ -0,0 +1,48 @@ +/* -*- 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_PerformanceStorageWorker_h +#define mozilla_dom_PerformanceStorageWorker_h + +#include "mozilla/Mutex.h" +#include "PerformanceStorage.h" + +namespace mozilla::dom { + +class WeakWorkerRef; +class WorkerPrivate; + +class PerformanceProxyData; + +class PerformanceStorageWorker final : public PerformanceStorage { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PerformanceStorageWorker, override) + + static already_AddRefed<PerformanceStorageWorker> Create( + WorkerPrivate* aWorkerPrivate); + + void ShutdownOnWorker(); + + void AddEntry(nsIHttpChannel* aChannel, + nsITimedChannel* aTimedChannel) override; + void AddEntry(const nsString& aEntryName, const nsString& aInitiatorType, + UniquePtr<PerformanceTimingData>&& aData) override; + void AddEntryOnWorker(UniquePtr<PerformanceProxyData>&& aData); + + private: + PerformanceStorageWorker(); + ~PerformanceStorageWorker(); + + Mutex mMutex; + + // Protected by mutex. + // Created and released on worker-thread. Used also on main-thread. + RefPtr<WeakWorkerRef> mWorkerRef MOZ_GUARDED_BY(mMutex); +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceStorageWorker_h diff --git a/dom/performance/PerformanceTiming.cpp b/dom/performance/PerformanceTiming.cpp new file mode 100644 index 0000000000..546783d686 --- /dev/null +++ b/dom/performance/PerformanceTiming.cpp @@ -0,0 +1,677 @@ +/* -*- 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 "PerformanceTiming.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/dom/PerformanceTimingBinding.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/Telemetry.h" +#include "nsIDocShell.h" +#include "nsIDocShellTreeItem.h" +#include "nsIHttpChannel.h" +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/Document.h" +#include "nsITimedChannel.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PerformanceTiming, mPerformance) + +/* static */ +PerformanceTimingData* PerformanceTimingData::Create( + nsITimedChannel* aTimedChannel, nsIHttpChannel* aChannel, + DOMHighResTimeStamp aZeroTime, nsAString& aInitiatorType, + nsAString& aEntryName) { + MOZ_ASSERT(NS_IsMainThread()); + + // Check if resource timing is prefed off. + if (!StaticPrefs::dom_enable_resource_timing()) { + return nullptr; + } + + if (!aChannel || !aTimedChannel) { + return nullptr; + } + + bool reportTiming = true; + aTimedChannel->GetReportResourceTiming(&reportTiming); + + if (!reportTiming) { + return nullptr; + } + + aTimedChannel->GetInitiatorType(aInitiatorType); + + // If the initiator type had no valid value, then set it to the default + // ("other") value. + if (aInitiatorType.IsEmpty()) { + aInitiatorType = u"other"_ns; + } + + // According to the spec, "The name attribute must return the resolved URL + // of the requested resource. This attribute must not change even if the + // fetch redirected to a different URL." + nsCOMPtr<nsIURI> originalURI; + aChannel->GetOriginalURI(getter_AddRefs(originalURI)); + + nsAutoCString name; + originalURI->GetSpec(name); + CopyUTF8toUTF16(name, aEntryName); + + // The nsITimedChannel argument will be used to gather all the timings. + // The nsIHttpChannel argument will be used to check if any cross-origin + // redirects occurred. + // The last argument is the "zero time" (offset). Since we don't want + // any offset for the resource timing, this will be set to "0" - the + // resource timing returns a relative timing (no offset). + return new PerformanceTimingData(aTimedChannel, aChannel, 0); +} + +PerformanceTiming::PerformanceTiming(Performance* aPerformance, + nsITimedChannel* aChannel, + nsIHttpChannel* aHttpChannel, + DOMHighResTimeStamp aZeroTime) + : mPerformance(aPerformance) { + MOZ_ASSERT(aPerformance, "Parent performance object should be provided"); + + mTimingData.reset(new PerformanceTimingData( + aChannel, aHttpChannel, + nsRFPService::ReduceTimePrecisionAsMSecs( + aZeroTime, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()))); + + // Non-null aHttpChannel implies that this PerformanceTiming object is being + // used for subresources, which is irrelevant to this probe. + if (!aHttpChannel && StaticPrefs::dom_enable_performance() && + IsTopLevelContentDocument()) { + glean::performance_time::response_start.AccumulateRawDuration( + TimeDuration::FromMilliseconds( + mTimingData->ResponseStartHighRes(aPerformance) - + mTimingData->ZeroTime())); + } +} + +// Copy the timing info from the channel so we don't need to keep the channel +// alive just to get the timestamps. +PerformanceTimingData::PerformanceTimingData(nsITimedChannel* aChannel, + nsIHttpChannel* aHttpChannel, + DOMHighResTimeStamp aZeroTime) + : mZeroTime(0.0), + mFetchStart(0.0), + mEncodedBodySize(0), + mTransferSize(0), + mDecodedBodySize(0), + mRedirectCount(0), + mAllRedirectsSameOrigin(true), + mAllRedirectsPassTAO(true), + mSecureConnection(false), + mTimingAllowed(true), + mInitialized(false) { + mInitialized = !!aChannel; + mZeroTime = aZeroTime; + + if (!StaticPrefs::dom_enable_performance()) { + mZeroTime = 0; + } + + nsCOMPtr<nsIURI> uri; + if (aHttpChannel) { + aHttpChannel->GetURI(getter_AddRefs(uri)); + } else { + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel); + if (httpChannel) { + httpChannel->GetURI(getter_AddRefs(uri)); + } + } + + if (uri) { + mSecureConnection = uri->SchemeIs("https"); + } + + if (aChannel) { + aChannel->GetAsyncOpen(&mAsyncOpen); + aChannel->GetAllRedirectsSameOrigin(&mAllRedirectsSameOrigin); + aChannel->GetAllRedirectsPassTimingAllowCheck(&mAllRedirectsPassTAO); + aChannel->GetRedirectCount(&mRedirectCount); + aChannel->GetRedirectStart(&mRedirectStart); + aChannel->GetRedirectEnd(&mRedirectEnd); + aChannel->GetDomainLookupStart(&mDomainLookupStart); + aChannel->GetDomainLookupEnd(&mDomainLookupEnd); + aChannel->GetConnectStart(&mConnectStart); + aChannel->GetSecureConnectionStart(&mSecureConnectionStart); + aChannel->GetConnectEnd(&mConnectEnd); + aChannel->GetRequestStart(&mRequestStart); + aChannel->GetResponseStart(&mResponseStart); + aChannel->GetCacheReadStart(&mCacheReadStart); + aChannel->GetResponseEnd(&mResponseEnd); + aChannel->GetCacheReadEnd(&mCacheReadEnd); + + aChannel->GetDispatchFetchEventStart(&mWorkerStart); + aChannel->GetHandleFetchEventStart(&mWorkerRequestStart); + // TODO: Track when FetchEvent.respondWith() promise resolves as + // ServiceWorker interception responseStart? + aChannel->GetHandleFetchEventEnd(&mWorkerResponseEnd); + + // The performance timing api essentially requires that the event timestamps + // have a strict relation with each other. The truth, however, is the + // browser engages in a number of speculative activities that sometimes mean + // connections and lookups begin at different times. Workaround that here by + // clamping these values to what we expect FetchStart to be. This means the + // later of AsyncOpen or WorkerStart times. + if (!mAsyncOpen.IsNull()) { + // We want to clamp to the expected FetchStart value. This is later of + // the AsyncOpen and WorkerStart values. + const TimeStamp* clampTime = &mAsyncOpen; + if (!mWorkerStart.IsNull() && mWorkerStart > mAsyncOpen) { + clampTime = &mWorkerStart; + } + + if (!mDomainLookupStart.IsNull() && mDomainLookupStart < *clampTime) { + mDomainLookupStart = *clampTime; + } + + if (!mDomainLookupEnd.IsNull() && mDomainLookupEnd < *clampTime) { + mDomainLookupEnd = *clampTime; + } + + if (!mConnectStart.IsNull() && mConnectStart < *clampTime) { + mConnectStart = *clampTime; + } + + if (mSecureConnection && !mSecureConnectionStart.IsNull() && + mSecureConnectionStart < *clampTime) { + mSecureConnectionStart = *clampTime; + } + + if (!mConnectEnd.IsNull() && mConnectEnd < *clampTime) { + mConnectEnd = *clampTime; + } + } + } + + // The aHttpChannel argument is null if this PerformanceTiming object is + // being used for navigation timing (which is only relevant for documents). + // It has a non-null value if this PerformanceTiming object is being used + // for resource timing, which can include document loads, both toplevel and + // in subframes, and resources linked from a document. + if (aHttpChannel) { + SetPropertiesFromHttpChannel(aHttpChannel, aChannel); + } +} + +PerformanceTimingData::PerformanceTimingData( + const IPCPerformanceTimingData& aIPCData) + : mNextHopProtocol(aIPCData.nextHopProtocol()), + mAsyncOpen(aIPCData.asyncOpen()), + mRedirectStart(aIPCData.redirectStart()), + mRedirectEnd(aIPCData.redirectEnd()), + mDomainLookupStart(aIPCData.domainLookupStart()), + mDomainLookupEnd(aIPCData.domainLookupEnd()), + mConnectStart(aIPCData.connectStart()), + mSecureConnectionStart(aIPCData.secureConnectionStart()), + mConnectEnd(aIPCData.connectEnd()), + mRequestStart(aIPCData.requestStart()), + mResponseStart(aIPCData.responseStart()), + mCacheReadStart(aIPCData.cacheReadStart()), + mResponseEnd(aIPCData.responseEnd()), + mCacheReadEnd(aIPCData.cacheReadEnd()), + mWorkerStart(aIPCData.workerStart()), + mWorkerRequestStart(aIPCData.workerRequestStart()), + mWorkerResponseEnd(aIPCData.workerResponseEnd()), + mZeroTime(aIPCData.zeroTime()), + mFetchStart(aIPCData.fetchStart()), + mEncodedBodySize(aIPCData.encodedBodySize()), + mTransferSize(aIPCData.transferSize()), + mDecodedBodySize(aIPCData.decodedBodySize()), + mRedirectCount(aIPCData.redirectCount()), + mAllRedirectsSameOrigin(aIPCData.allRedirectsSameOrigin()), + mAllRedirectsPassTAO(aIPCData.allRedirectsPassTAO()), + mSecureConnection(aIPCData.secureConnection()), + mTimingAllowed(aIPCData.timingAllowed()), + mInitialized(aIPCData.initialized()) { + for (const auto& serverTimingData : aIPCData.serverTiming()) { + RefPtr<nsServerTiming> timing = new nsServerTiming(); + timing->SetName(serverTimingData.name()); + timing->SetDuration(serverTimingData.duration()); + timing->SetDescription(serverTimingData.description()); + mServerTiming.AppendElement(timing); + } +} + +IPCPerformanceTimingData PerformanceTimingData::ToIPC() { + nsTArray<IPCServerTiming> ipcServerTiming; + for (auto& serverTimingData : mServerTiming) { + nsAutoCString name; + Unused << serverTimingData->GetName(name); + double duration = 0; + Unused << serverTimingData->GetDuration(&duration); + nsAutoCString description; + Unused << serverTimingData->GetDescription(description); + ipcServerTiming.AppendElement(IPCServerTiming(name, duration, description)); + } + return IPCPerformanceTimingData( + ipcServerTiming, mNextHopProtocol, mAsyncOpen, mRedirectStart, + mRedirectEnd, mDomainLookupStart, mDomainLookupEnd, mConnectStart, + mSecureConnectionStart, mConnectEnd, mRequestStart, mResponseStart, + mCacheReadStart, mResponseEnd, mCacheReadEnd, mWorkerStart, + mWorkerRequestStart, mWorkerResponseEnd, mZeroTime, mFetchStart, + mEncodedBodySize, mTransferSize, mDecodedBodySize, mRedirectCount, + mAllRedirectsSameOrigin, mAllRedirectsPassTAO, mSecureConnection, + mTimingAllowed, mInitialized); +} + +void PerformanceTimingData::SetPropertiesFromHttpChannel( + nsIHttpChannel* aHttpChannel, nsITimedChannel* aChannel) { + MOZ_ASSERT(aHttpChannel); + + nsAutoCString protocol; + Unused << aHttpChannel->GetProtocolVersion(protocol); + CopyUTF8toUTF16(protocol, mNextHopProtocol); + + Unused << aHttpChannel->GetEncodedBodySize(&mEncodedBodySize); + Unused << aHttpChannel->GetTransferSize(&mTransferSize); + Unused << aHttpChannel->GetDecodedBodySize(&mDecodedBodySize); + if (mDecodedBodySize == 0) { + mDecodedBodySize = mEncodedBodySize; + } + + mTimingAllowed = CheckAllowedOrigin(aHttpChannel, aChannel); + aChannel->GetAllRedirectsPassTimingAllowCheck(&mAllRedirectsPassTAO); + + aChannel->GetNativeServerTiming(mServerTiming); +} + +PerformanceTiming::~PerformanceTiming() = default; + +DOMHighResTimeStamp PerformanceTimingData::FetchStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!mFetchStart) { + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + MOZ_ASSERT(!mAsyncOpen.IsNull(), + "The fetch start time stamp should always be " + "valid if the performance timing is enabled"); + if (!mAsyncOpen.IsNull()) { + if (!mWorkerRequestStart.IsNull() && mWorkerRequestStart > mAsyncOpen) { + mFetchStart = TimeStampToDOMHighRes(aPerformance, mWorkerRequestStart); + } else { + mFetchStart = TimeStampToDOMHighRes(aPerformance, mAsyncOpen); + } + } + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + mFetchStart, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +DOMTimeMilliSec PerformanceTiming::FetchStart() { + return static_cast<int64_t>(mTimingData->FetchStartHighRes(mPerformance)); +} + +bool PerformanceTimingData::CheckAllowedOrigin(nsIHttpChannel* aResourceChannel, + nsITimedChannel* aChannel) { + if (!IsInitialized()) { + return false; + } + + // Check that the current document passes the ckeck. + nsCOMPtr<nsILoadInfo> loadInfo = aResourceChannel->LoadInfo(); + + // TYPE_DOCUMENT loads have no loadingPrincipal. + if (loadInfo->GetExternalContentPolicyType() == + ExtContentPolicy::TYPE_DOCUMENT) { + return true; + } + + nsCOMPtr<nsIPrincipal> principal = loadInfo->GetLoadingPrincipal(); + + // Check if the resource is either same origin as the page that started + // the load, or if the response contains the proper Timing-Allow-Origin + // header with the domain of the page that started the load. + return aChannel->TimingAllowCheck(principal); +} + +uint8_t PerformanceTimingData::GetRedirectCount() const { + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return 0; + } + if (!mAllRedirectsSameOrigin) { + return 0; + } + return mRedirectCount; +} + +bool PerformanceTimingData::ShouldReportCrossOriginRedirect( + bool aEnsureSameOriginAndIgnoreTAO) const { + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return false; + } + + if (!mTimingAllowed || mRedirectCount == 0) { + return false; + } + + // If the redirect count is 0, or if one of the cross-origin + // redirects doesn't have the proper Timing-Allow-Origin header, + // then RedirectStart and RedirectEnd will be set to zero + return aEnsureSameOriginAndIgnoreTAO ? mAllRedirectsSameOrigin + : mAllRedirectsPassTAO; +} + +DOMHighResTimeStamp PerformanceTimingData::AsyncOpenHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized() || + mAsyncOpen.IsNull()) { + return mZeroTime; + } + DOMHighResTimeStamp rawValue = + TimeStampToDOMHighRes(aPerformance, mAsyncOpen); + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +DOMHighResTimeStamp PerformanceTimingData::WorkerStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized() || + mWorkerStart.IsNull()) { + return mZeroTime; + } + DOMHighResTimeStamp rawValue = + TimeStampToDOMHighRes(aPerformance, mWorkerStart); + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +/** + * RedirectStartHighRes() is used by both the navigation timing and the + * resource timing. Since, navigation timing and resource timing check and + * interpret cross-domain redirects in a different manner, + * RedirectStartHighRes() will make no checks for cross-domain redirect. + * It's up to the consumers of this method (PerformanceTiming::RedirectStart() + * and PerformanceResourceTiming::RedirectStart() to make such verifications. + * + * @return a valid timing if the Performance Timing is enabled + */ +DOMHighResTimeStamp PerformanceTimingData::RedirectStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + return TimeStampToReducedDOMHighResOrFetchStart(aPerformance, mRedirectStart); +} + +DOMTimeMilliSec PerformanceTiming::RedirectStart() { + if (!mTimingData->IsInitialized()) { + return 0; + } + // We have to check if all the redirect URIs had the same origin (since there + // is no check in RedirectStartHighRes()) + if (mTimingData->AllRedirectsSameOrigin() && + mTimingData->RedirectCountReal()) { + return static_cast<int64_t>( + mTimingData->RedirectStartHighRes(mPerformance)); + } + return 0; +} + +/** + * RedirectEndHighRes() is used by both the navigation timing and the resource + * timing. Since, navigation timing and resource timing check and interpret + * cross-domain redirects in a different manner, RedirectEndHighRes() will make + * no checks for cross-domain redirect. It's up to the consumers of this method + * (PerformanceTiming::RedirectEnd() and + * PerformanceResourceTiming::RedirectEnd() to make such verifications. + * + * @return a valid timing if the Performance Timing is enabled + */ +DOMHighResTimeStamp PerformanceTimingData::RedirectEndHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + return TimeStampToReducedDOMHighResOrFetchStart(aPerformance, mRedirectEnd); +} + +DOMTimeMilliSec PerformanceTiming::RedirectEnd() { + if (!mTimingData->IsInitialized()) { + return 0; + } + // We have to check if all the redirect URIs had the same origin (since there + // is no check in RedirectEndHighRes()) + if (mTimingData->AllRedirectsSameOrigin() && + mTimingData->RedirectCountReal()) { + return static_cast<int64_t>(mTimingData->RedirectEndHighRes(mPerformance)); + } + return 0; +} + +DOMHighResTimeStamp PerformanceTimingData::DomainLookupStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + // Bug 1637985 - DomainLookup information may be useful for fingerprinting. + if (aPerformance->ShouldResistFingerprinting()) { + return FetchStartHighRes(aPerformance); + } + return TimeStampToReducedDOMHighResOrFetchStart(aPerformance, + mDomainLookupStart); +} + +DOMTimeMilliSec PerformanceTiming::DomainLookupStart() { + return static_cast<int64_t>( + mTimingData->DomainLookupStartHighRes(mPerformance)); +} + +DOMHighResTimeStamp PerformanceTimingData::DomainLookupEndHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + // Bug 1637985 - DomainLookup information may be useful for fingerprinting. + if (aPerformance->ShouldResistFingerprinting()) { + return FetchStartHighRes(aPerformance); + } + // Bug 1155008 - nsHttpTransaction is racy. Return DomainLookupStart when null + if (mDomainLookupEnd.IsNull()) { + return DomainLookupStartHighRes(aPerformance); + } + DOMHighResTimeStamp rawValue = + TimeStampToDOMHighRes(aPerformance, mDomainLookupEnd); + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +DOMTimeMilliSec PerformanceTiming::DomainLookupEnd() { + return static_cast<int64_t>( + mTimingData->DomainLookupEndHighRes(mPerformance)); +} + +DOMHighResTimeStamp PerformanceTimingData::ConnectStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + if (mConnectStart.IsNull()) { + return DomainLookupEndHighRes(aPerformance); + } + DOMHighResTimeStamp rawValue = + TimeStampToDOMHighRes(aPerformance, mConnectStart); + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +DOMTimeMilliSec PerformanceTiming::ConnectStart() { + return static_cast<int64_t>(mTimingData->ConnectStartHighRes(mPerformance)); +} + +DOMHighResTimeStamp PerformanceTimingData::SecureConnectionStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + if (!mSecureConnection) { + return 0; // We use 0 here, because mZeroTime is sometimes set to the + // navigation start time. + } + if (mSecureConnectionStart.IsNull()) { + return ConnectStartHighRes(aPerformance); + } + DOMHighResTimeStamp rawValue = + TimeStampToDOMHighRes(aPerformance, mSecureConnectionStart); + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +DOMTimeMilliSec PerformanceTiming::SecureConnectionStart() { + return static_cast<int64_t>( + mTimingData->SecureConnectionStartHighRes(mPerformance)); +} + +DOMHighResTimeStamp PerformanceTimingData::ConnectEndHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + // Bug 1155008 - nsHttpTransaction is racy. Return ConnectStart when null + if (mConnectEnd.IsNull()) { + return ConnectStartHighRes(aPerformance); + } + DOMHighResTimeStamp rawValue = + TimeStampToDOMHighRes(aPerformance, mConnectEnd); + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +DOMTimeMilliSec PerformanceTiming::ConnectEnd() { + return static_cast<int64_t>(mTimingData->ConnectEndHighRes(mPerformance)); +} + +DOMHighResTimeStamp PerformanceTimingData::RequestStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + + if (mRequestStart.IsNull()) { + mRequestStart = mWorkerRequestStart; + } + + return TimeStampToReducedDOMHighResOrFetchStart(aPerformance, mRequestStart); +} + +DOMTimeMilliSec PerformanceTiming::RequestStart() { + return static_cast<int64_t>(mTimingData->RequestStartHighRes(mPerformance)); +} + +DOMHighResTimeStamp PerformanceTimingData::ResponseStartHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + if (mResponseStart.IsNull() || + (!mCacheReadStart.IsNull() && mCacheReadStart < mResponseStart)) { + mResponseStart = mCacheReadStart; + } + + if (mResponseStart.IsNull() || + (!mRequestStart.IsNull() && mResponseStart < mRequestStart)) { + mResponseStart = mRequestStart; + } + return TimeStampToReducedDOMHighResOrFetchStart(aPerformance, mResponseStart); +} + +DOMTimeMilliSec PerformanceTiming::ResponseStart() { + return static_cast<int64_t>(mTimingData->ResponseStartHighRes(mPerformance)); +} + +DOMHighResTimeStamp PerformanceTimingData::ResponseEndHighRes( + Performance* aPerformance) { + MOZ_ASSERT(aPerformance); + + if (!StaticPrefs::dom_enable_performance() || !IsInitialized()) { + return mZeroTime; + } + if (mResponseEnd.IsNull() || + (!mCacheReadEnd.IsNull() && mCacheReadEnd < mResponseEnd)) { + mResponseEnd = mCacheReadEnd; + } + if (mResponseEnd.IsNull()) { + mResponseEnd = mWorkerResponseEnd; + } + // Bug 1155008 - nsHttpTransaction is racy. Return ResponseStart when null + if (mResponseEnd.IsNull()) { + return ResponseStartHighRes(aPerformance); + } + DOMHighResTimeStamp rawValue = + TimeStampToDOMHighRes(aPerformance, mResponseEnd); + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawValue, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); +} + +DOMTimeMilliSec PerformanceTiming::ResponseEnd() { + return static_cast<int64_t>(mTimingData->ResponseEndHighRes(mPerformance)); +} + +JSObject* PerformanceTiming::WrapObject(JSContext* cx, + JS::Handle<JSObject*> aGivenProto) { + return PerformanceTiming_Binding::Wrap(cx, this, aGivenProto); +} + +bool PerformanceTiming::IsTopLevelContentDocument() const { + nsCOMPtr<Document> document = mPerformance->GetDocumentIfCurrent(); + if (!document) { + return false; + } + + if (BrowsingContext* bc = document->GetBrowsingContext()) { + return bc->IsTopContent(); + } + return false; +} + +nsTArray<nsCOMPtr<nsIServerTiming>> PerformanceTimingData::GetServerTiming() { + if (!StaticPrefs::dom_enable_performance() || !IsInitialized() || + !TimingAllowed()) { + return nsTArray<nsCOMPtr<nsIServerTiming>>(); + } + + return mServerTiming.Clone(); +} + +} // namespace mozilla::dom diff --git a/dom/performance/PerformanceTiming.h b/dom/performance/PerformanceTiming.h new file mode 100644 index 0000000000..5c14c009d7 --- /dev/null +++ b/dom/performance/PerformanceTiming.h @@ -0,0 +1,595 @@ +/* -*- 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_PerformanceTiming_h +#define mozilla_dom_PerformanceTiming_h + +#include "mozilla/Attributes.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/StaticPrefs_dom.h" +#include "nsContentUtils.h" +#include "nsDOMNavigationTiming.h" +#include "nsRFPService.h" +#include "nsWrapperCache.h" +#include "Performance.h" +#include "nsITimedChannel.h" +#include "mozilla/dom/PerformanceTimingTypes.h" +#include "mozilla/ipc/IPDLParamTraits.h" +#include "ipc/IPCMessageUtils.h" +#include "ipc/IPCMessageUtilsSpecializations.h" +#include "mozilla/net/nsServerTiming.h" + +class nsIHttpChannel; + +namespace mozilla::dom { + +class PerformanceTiming; + +class PerformanceTimingData final { + friend class PerformanceTiming; + friend struct mozilla::ipc::IPDLParamTraits< + mozilla::dom::PerformanceTimingData>; + + public: + PerformanceTimingData() = default; // For deserialization + // This can return null. + static PerformanceTimingData* Create(nsITimedChannel* aChannel, + nsIHttpChannel* aHttpChannel, + DOMHighResTimeStamp aZeroTime, + nsAString& aInitiatorType, + nsAString& aEntryName); + + PerformanceTimingData(nsITimedChannel* aChannel, nsIHttpChannel* aHttpChannel, + DOMHighResTimeStamp aZeroTime); + + explicit PerformanceTimingData(const IPCPerformanceTimingData& aIPCData); + + IPCPerformanceTimingData ToIPC(); + + void SetPropertiesFromHttpChannel(nsIHttpChannel* aHttpChannel, + nsITimedChannel* aChannel); + + bool IsInitialized() const { return mInitialized; } + + const nsString& NextHopProtocol() const { return mNextHopProtocol; } + + uint64_t TransferSize() const { return mTransferSize; } + + uint64_t EncodedBodySize() const { return mEncodedBodySize; } + + uint64_t DecodedBodySize() const { return mDecodedBodySize; } + + /** + * @param aStamp + * The TimeStamp recorded for a specific event. This TimeStamp can + * be null. + * @return the duration of an event with a given TimeStamp, relative to the + * navigationStart TimeStamp (the moment the user landed on the + * page), if the given TimeStamp is valid. Otherwise, it will return + * the FetchStart timing value. + */ + inline DOMHighResTimeStamp TimeStampToReducedDOMHighResOrFetchStart( + Performance* aPerformance, TimeStamp aStamp) { + MOZ_ASSERT(aPerformance); + + if (aStamp.IsNull()) { + return FetchStartHighRes(aPerformance); + } + + DOMHighResTimeStamp rawTimestamp = + TimeStampToDOMHighRes(aPerformance, aStamp); + + return nsRFPService::ReduceTimePrecisionAsMSecs( + rawTimestamp, aPerformance->GetRandomTimelineSeed(), + aPerformance->GetRTPCallerType()); + } + + /** + * The nsITimedChannel records an absolute timestamp for each event. + * The nsDOMNavigationTiming will record the moment when the user landed on + * the page. This is a window.performance unique timestamp, so it can be used + * for all the events (navigation timing and resource timing events). + * + * The algorithm operates in 2 steps: + * 1. The first step is to subtract the two timestamps: the argument (the + * event's timestamp) and the navigation start timestamp. This will result in + * a relative timestamp of the event (relative to the navigation start - + * window.performance.timing.navigationStart). + * 2. The second step is to add any required offset (the mZeroTime). For now, + * this offset value is either 0 (for the resource timing), or equal to + * "performance.navigationStart" (for navigation timing). + * For the resource timing, mZeroTime is set to 0, causing the result to be a + * relative time. + * For the navigation timing, mZeroTime is set to + * "performance.navigationStart" causing the result be an absolute time. + * + * @param aStamp + * The TimeStamp recorded for a specific event. This TimeStamp can't + * be null. + * @return number of milliseconds value as one of: + * - relative to the navigation start time, time the user has landed on the + * page + * - an absolute wall clock time since the unix epoch + */ + inline DOMHighResTimeStamp TimeStampToDOMHighRes(Performance* aPerformance, + TimeStamp aStamp) const { + MOZ_ASSERT(aPerformance); + MOZ_ASSERT(!aStamp.IsNull()); + + TimeDuration duration = aStamp - aPerformance->CreationTimeStamp(); + return duration.ToMilliseconds() + mZeroTime; + } + + // The last channel's AsyncOpen time. This may occur before the FetchStart + // in some cases. + DOMHighResTimeStamp AsyncOpenHighRes(Performance* aPerformance); + + // High resolution (used by resource timing) + DOMHighResTimeStamp WorkerStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp FetchStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp RedirectStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp RedirectEndHighRes(Performance* aPerformance); + DOMHighResTimeStamp DomainLookupStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp DomainLookupEndHighRes(Performance* aPerformance); + DOMHighResTimeStamp ConnectStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp SecureConnectionStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp ConnectEndHighRes(Performance* aPerformance); + DOMHighResTimeStamp RequestStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp ResponseStartHighRes(Performance* aPerformance); + DOMHighResTimeStamp ResponseEndHighRes(Performance* aPerformance); + + DOMHighResTimeStamp ZeroTime() const { return mZeroTime; } + + uint8_t RedirectCountReal() const { return mRedirectCount; } + uint8_t GetRedirectCount() const; + + bool AllRedirectsSameOrigin() const { return mAllRedirectsSameOrigin; } + + // If this is false the values of redirectStart/End will be 0 This is false if + // no redirects occured, or if any of the responses failed the + // timing-allow-origin check in HttpBaseChannel::TimingAllowCheck + // + // If aEnsureSameOriginAndIgnoreTAO is false, it checks if all redirects pass + // TAO. When it is true, it checks if all redirects are same-origin and + // ignores the result of TAO. + bool ShouldReportCrossOriginRedirect( + bool aEnsureSameOriginAndIgnoreTAO) const; + + // Cached result of CheckAllowedOrigin. If false, security sensitive + // attributes of the resourceTiming object will be set to 0 + bool TimingAllowed() const { return mTimingAllowed; } + + nsTArray<nsCOMPtr<nsIServerTiming>> GetServerTiming(); + + private: + // Checks if the resource is either same origin as the page that started + // the load, or if the response contains the Timing-Allow-Origin header + // with a value of * or matching the domain of the loading Principal + bool CheckAllowedOrigin(nsIHttpChannel* aResourceChannel, + nsITimedChannel* aChannel); + + nsTArray<nsCOMPtr<nsIServerTiming>> mServerTiming; + nsString mNextHopProtocol; + + TimeStamp mAsyncOpen; + TimeStamp mRedirectStart; + TimeStamp mRedirectEnd; + TimeStamp mDomainLookupStart; + TimeStamp mDomainLookupEnd; + TimeStamp mConnectStart; + TimeStamp mSecureConnectionStart; + TimeStamp mConnectEnd; + TimeStamp mRequestStart; + TimeStamp mResponseStart; + TimeStamp mCacheReadStart; + TimeStamp mResponseEnd; + TimeStamp mCacheReadEnd; + + // ServiceWorker interception timing information + TimeStamp mWorkerStart; + TimeStamp mWorkerRequestStart; + TimeStamp mWorkerResponseEnd; + + // This is an offset that will be added to each timing ([ms] resolution). + // There are only 2 possible values: (1) logicaly equal to navigationStart + // TimeStamp (results are absolute timstamps - wallclock); (2) "0" (results + // are relative to the navigation start). + DOMHighResTimeStamp mZeroTime = 0; + + DOMHighResTimeStamp mFetchStart = 0; + + uint64_t mEncodedBodySize = 0; + uint64_t mTransferSize = 0; + uint64_t mDecodedBodySize = 0; + + uint8_t mRedirectCount = 0; + + bool mAllRedirectsSameOrigin = false; + + bool mAllRedirectsPassTAO = false; + + bool mSecureConnection = false; + + bool mTimingAllowed = false; + + bool mInitialized = false; +}; + +// Script "performance.timing" object +class PerformanceTiming final : public nsWrapperCache { + public: + /** + * @param aPerformance + * The performance object (the JS parent). + * This will allow access to "window.performance.timing" attribute + * for the navigation timing (can't be null). + * @param aChannel + * An nsITimedChannel used to gather all the networking timings by + * both the navigation timing and the resource timing (can't be null). + * @param aHttpChannel + * An nsIHttpChannel (the resource's http channel). + * This will be used by the resource timing cross-domain check + * algorithm. + * Argument is null for the navigation timing (navigation timing uses + * another algorithm for the cross-domain redirects). + * @param aZeroTime + * The offset that will be added to the timestamp of each event. This + * argument should be equal to performance.navigationStart for + * navigation timing and "0" for the resource timing. + */ + PerformanceTiming(Performance* aPerformance, nsITimedChannel* aChannel, + nsIHttpChannel* aHttpChannel, + DOMHighResTimeStamp aZeroTime); + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(PerformanceTiming) + NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(PerformanceTiming) + + nsDOMNavigationTiming* GetDOMTiming() const { + return mPerformance->GetDOMTiming(); + } + + Performance* GetParentObject() const { return mPerformance; } + + virtual JSObject* WrapObject(JSContext* cx, + JS::Handle<JSObject*> aGivenProto) override; + + // PerformanceNavigation WebIDL methods + DOMTimeMilliSec NavigationStart() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetNavigationStart(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec UnloadEventStart() { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetUnloadEventStart(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec UnloadEventEnd() { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetUnloadEventEnd(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + // Low resolution (used by navigation timing) + DOMTimeMilliSec FetchStart(); + DOMTimeMilliSec RedirectStart(); + DOMTimeMilliSec RedirectEnd(); + DOMTimeMilliSec DomainLookupStart(); + DOMTimeMilliSec DomainLookupEnd(); + DOMTimeMilliSec ConnectStart(); + DOMTimeMilliSec SecureConnectionStart(); + DOMTimeMilliSec ConnectEnd(); + DOMTimeMilliSec RequestStart(); + DOMTimeMilliSec ResponseStart(); + DOMTimeMilliSec ResponseEnd(); + + DOMTimeMilliSec DomLoading() { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetDomLoading(), mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec DomInteractive() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetDomInteractive(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec DomContentLoadedEventStart() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetDomContentLoadedEventStart(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec DomContentLoadedEventEnd() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetDomContentLoadedEventEnd(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec DomComplete() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetDomComplete(), mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec LoadEventStart() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetLoadEventStart(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec LoadEventEnd() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetLoadEventEnd(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec TimeToNonBlankPaint() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetTimeToNonBlankPaint(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec TimeToContentfulPaint() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetTimeToContentfulComposite(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec TimeToDOMContentFlushed() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetTimeToDOMContentFlushed(), + mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + DOMTimeMilliSec TimeToFirstInteractive() const { + if (!StaticPrefs::dom_enable_performance()) { + return 0; + } + return nsRFPService::ReduceTimePrecisionAsMSecs( + GetDOMTiming()->GetTimeToTTFI(), mPerformance->GetRandomTimelineSeed(), + mPerformance->GetRTPCallerType()); + } + + PerformanceTimingData* Data() const { return mTimingData.get(); } + + private: + ~PerformanceTiming(); + + bool IsTopLevelContentDocument() const; + + RefPtr<Performance> mPerformance; + + UniquePtr<PerformanceTimingData> mTimingData; +}; + +} // namespace mozilla::dom + +namespace mozilla::ipc { + +template <> +struct IPDLParamTraits<mozilla::dom::PerformanceTimingData> { + using paramType = mozilla::dom::PerformanceTimingData; + static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor, + const paramType& aParam) { + WriteIPDLParam(aWriter, aActor, aParam.mServerTiming); + WriteIPDLParam(aWriter, aActor, aParam.mNextHopProtocol); + WriteIPDLParam(aWriter, aActor, aParam.mAsyncOpen); + WriteIPDLParam(aWriter, aActor, aParam.mRedirectStart); + WriteIPDLParam(aWriter, aActor, aParam.mRedirectEnd); + WriteIPDLParam(aWriter, aActor, aParam.mDomainLookupStart); + WriteIPDLParam(aWriter, aActor, aParam.mDomainLookupEnd); + WriteIPDLParam(aWriter, aActor, aParam.mConnectStart); + WriteIPDLParam(aWriter, aActor, aParam.mSecureConnectionStart); + WriteIPDLParam(aWriter, aActor, aParam.mConnectEnd); + WriteIPDLParam(aWriter, aActor, aParam.mRequestStart); + WriteIPDLParam(aWriter, aActor, aParam.mResponseStart); + WriteIPDLParam(aWriter, aActor, aParam.mCacheReadStart); + WriteIPDLParam(aWriter, aActor, aParam.mResponseEnd); + WriteIPDLParam(aWriter, aActor, aParam.mCacheReadEnd); + WriteIPDLParam(aWriter, aActor, aParam.mWorkerStart); + WriteIPDLParam(aWriter, aActor, aParam.mWorkerRequestStart); + WriteIPDLParam(aWriter, aActor, aParam.mWorkerResponseEnd); + WriteIPDLParam(aWriter, aActor, aParam.mZeroTime); + WriteIPDLParam(aWriter, aActor, aParam.mFetchStart); + WriteIPDLParam(aWriter, aActor, aParam.mEncodedBodySize); + WriteIPDLParam(aWriter, aActor, aParam.mTransferSize); + WriteIPDLParam(aWriter, aActor, aParam.mDecodedBodySize); + WriteIPDLParam(aWriter, aActor, aParam.mRedirectCount); + WriteIPDLParam(aWriter, aActor, aParam.mAllRedirectsSameOrigin); + WriteIPDLParam(aWriter, aActor, aParam.mAllRedirectsPassTAO); + WriteIPDLParam(aWriter, aActor, aParam.mSecureConnection); + WriteIPDLParam(aWriter, aActor, aParam.mTimingAllowed); + WriteIPDLParam(aWriter, aActor, aParam.mInitialized); + } + + static bool Read(IPC::MessageReader* aReader, IProtocol* aActor, + paramType* aResult) { + if (!ReadIPDLParam(aReader, aActor, &aResult->mServerTiming)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mNextHopProtocol)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mAsyncOpen)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectEnd)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mDomainLookupStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mDomainLookupEnd)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mConnectStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mSecureConnectionStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mConnectEnd)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mRequestStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mCacheReadStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseEnd)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mCacheReadEnd)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerRequestStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerResponseEnd)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mZeroTime)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mFetchStart)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mEncodedBodySize)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mTransferSize)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mDecodedBodySize)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectCount)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mAllRedirectsSameOrigin)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mAllRedirectsPassTAO)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mSecureConnection)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mTimingAllowed)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &aResult->mInitialized)) { + return false; + } + return true; + } +}; + +template <> +struct IPDLParamTraits<nsIServerTiming*> { + static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor, + nsIServerTiming* aParam) { + nsAutoCString name; + Unused << aParam->GetName(name); + double duration = 0; + Unused << aParam->GetDuration(&duration); + nsAutoCString description; + Unused << aParam->GetDescription(description); + WriteIPDLParam(aWriter, aActor, name); + WriteIPDLParam(aWriter, aActor, duration); + WriteIPDLParam(aWriter, aActor, description); + } + + static bool Read(IPC::MessageReader* aReader, IProtocol* aActor, + RefPtr<nsIServerTiming>* aResult) { + nsAutoCString name; + double duration; + nsAutoCString description; + if (!ReadIPDLParam(aReader, aActor, &name)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &duration)) { + return false; + } + if (!ReadIPDLParam(aReader, aActor, &description)) { + return false; + } + + RefPtr<nsServerTiming> timing = new nsServerTiming(); + timing->SetName(name); + timing->SetDuration(duration); + timing->SetDescription(description); + *aResult = timing.forget(); + return true; + } +}; + +} // namespace mozilla::ipc + +#endif // mozilla_dom_PerformanceTiming_h diff --git a/dom/performance/PerformanceTimingTypes.ipdlh b/dom/performance/PerformanceTimingTypes.ipdlh new file mode 100644 index 0000000000..fbbdf44636 --- /dev/null +++ b/dom/performance/PerformanceTimingTypes.ipdlh @@ -0,0 +1,50 @@ +/* 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/. */ + +using class mozilla::TimeStamp from "mozilla/TimeStamp.h"; +using DOMHighResTimeStamp from "nsDOMNavigationTiming.h"; + +namespace mozilla { +namespace dom { + +struct IPCServerTiming { + nsCString name; + double duration; + nsCString description; +}; + +struct IPCPerformanceTimingData { + IPCServerTiming[] serverTiming; + nsString nextHopProtocol; + TimeStamp asyncOpen; + TimeStamp redirectStart; + TimeStamp redirectEnd; + TimeStamp domainLookupStart; + TimeStamp domainLookupEnd; + TimeStamp connectStart; + TimeStamp secureConnectionStart; + TimeStamp connectEnd; + TimeStamp requestStart; + TimeStamp responseStart; + TimeStamp cacheReadStart; + TimeStamp responseEnd; + TimeStamp cacheReadEnd; + TimeStamp workerStart; + TimeStamp workerRequestStart; + TimeStamp workerResponseEnd; + DOMHighResTimeStamp zeroTime; + DOMHighResTimeStamp fetchStart; + uint64_t encodedBodySize; + uint64_t transferSize; + uint64_t decodedBodySize; + uint8_t redirectCount; + bool allRedirectsSameOrigin; + bool allRedirectsPassTAO; + bool secureConnection; + bool timingAllowed; + bool initialized; +}; + +} +} diff --git a/dom/performance/PerformanceWorker.cpp b/dom/performance/PerformanceWorker.cpp new file mode 100644 index 0000000000..1c77910a78 --- /dev/null +++ b/dom/performance/PerformanceWorker.cpp @@ -0,0 +1,61 @@ +/* -*- 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 "PerformanceWorker.h" +#include "mozilla/dom/WorkerScope.h" +#include "mozilla/StaticPrefs_dom.h" + +namespace mozilla::dom { + +PerformanceWorker::PerformanceWorker(WorkerGlobalScope* aGlobalScope) + : Performance(aGlobalScope) { + MOZ_ASSERT(aGlobalScope); + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_DIAGNOSTIC_ASSERT(workerPrivate); + workerPrivate->AssertIsOnWorkerThread(); +} + +PerformanceWorker::~PerformanceWorker() { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + if (workerPrivate) { + workerPrivate->AssertIsOnWorkerThread(); + } +} + +void PerformanceWorker::InsertUserEntry(PerformanceEntry* aEntry) { + if (StaticPrefs::dom_performance_enable_user_timing_logging()) { + nsAutoCString uri; + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_DIAGNOSTIC_ASSERT(workerPrivate); + nsCOMPtr<nsIURI> scriptURI = workerPrivate->GetResolvedScriptURI(); + if (!scriptURI || NS_FAILED(scriptURI->GetHost(uri))) { + // If we have no URI, just put in "none". + uri.AssignLiteral("none"); + } + Performance::LogEntry(aEntry, uri); + } + Performance::InsertUserEntry(aEntry); +} + +TimeStamp PerformanceWorker::CreationTimeStamp() const { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_DIAGNOSTIC_ASSERT(workerPrivate); + return workerPrivate->CreationTimeStamp(); +} + +DOMHighResTimeStamp PerformanceWorker::CreationTime() const { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_DIAGNOSTIC_ASSERT(workerPrivate); + return workerPrivate->CreationTime(); +} + +uint64_t PerformanceWorker::GetRandomTimelineSeed() { + WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_DIAGNOSTIC_ASSERT(workerPrivate); + return workerPrivate->GetRandomTimelineSeed(); +} + +} // namespace mozilla::dom diff --git a/dom/performance/PerformanceWorker.h b/dom/performance/PerformanceWorker.h new file mode 100644 index 0000000000..f0539aa02d --- /dev/null +++ b/dom/performance/PerformanceWorker.h @@ -0,0 +1,96 @@ +/* -*- 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_PerformanceWorker_h +#define mozilla_dom_PerformanceWorker_h + +#include "Performance.h" + +namespace mozilla::dom { + +class WorkerGlobalScope; + +class PerformanceWorker final : public Performance { + public: + explicit PerformanceWorker(WorkerGlobalScope* aGlobalScope); + + PerformanceStorage* AsPerformanceStorage() override { + MOZ_CRASH("This should not be called on workers."); + return nullptr; + } + + virtual PerformanceTiming* Timing() override { + MOZ_CRASH("This should not be called on workers."); + return nullptr; + } + + virtual PerformanceNavigation* Navigation() override { + MOZ_CRASH("This should not be called on workers."); + return nullptr; + } + + virtual void SetFCPTimingEntry(PerformancePaintTiming* aEntry) override { + MOZ_CRASH("This should not be called on workers."); + } + + TimeStamp CreationTimeStamp() const override; + + DOMHighResTimeStamp CreationTime() const override; + + virtual void GetMozMemory(JSContext* aCx, + JS::MutableHandle<JSObject*> aObj) override { + MOZ_CRASH("This should not be called on workers."); + } + + virtual nsDOMNavigationTiming* GetDOMTiming() const override { + MOZ_CRASH("This should not be called on workers."); + return nullptr; + } + + virtual uint64_t GetRandomTimelineSeed() override; + + virtual nsITimedChannel* GetChannel() const override { + MOZ_CRASH("This should not be called on workers."); + return nullptr; + } + + void QueueNavigationTimingEntry() override { + MOZ_CRASH("This should not be called on workers."); + } + + void UpdateNavigationTimingEntry() override { + MOZ_CRASH("This should not be called on workers."); + } + + void InsertEventTimingEntry(PerformanceEventTiming*) override { + MOZ_CRASH("This should not be called on workers."); + } + + void BufferEventTimingEntryIfNeeded(PerformanceEventTiming*) override { + MOZ_CRASH("This should not be called on workers."); + } + + void DispatchPendingEventTimingEntries() override { + MOZ_CRASH("This should not be called on workders."); + } + + class EventCounts* EventCounts() override { + MOZ_CRASH("This should not be called on workers"); + } + + protected: + ~PerformanceWorker(); + + void InsertUserEntry(PerformanceEntry* aEntry) override; + + void DispatchBufferFullEvent() override { + // Nothing to do here. See bug 1432758. + } +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_PerformanceWorker_h diff --git a/dom/performance/metrics.yaml b/dom/performance/metrics.yaml new file mode 100644 index 0000000000..995afc1024 --- /dev/null +++ b/dom/performance/metrics.yaml @@ -0,0 +1,32 @@ +# 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/. + +# Adding a new metric? We have docs for that! +# https://firefox-source-docs.mozilla.org/toolkit/components/glean/user/new_definitions_file.html + +--- +$schema: moz://mozilla.org/schemas/glean/metrics/2-0-0 +$tags: + - 'Core :: DOM: Performance' + +performance.time: + response_start: + type: timing_distribution + time_unit: millisecond + telemetry_mirror: TIME_TO_RESPONSE_START_MS + description: > + Time from navigationStart to responseStart as per the W3C + Performance Timing API. + (Migrated from the geckoview metric of the same name.) + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1344893 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1489524 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1580077 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1877842 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1580077#c10 + notification_emails: + - vchin@mozilla.com + - perf-telemetry-alerts@mozilla.com + expires: never diff --git a/dom/performance/moz.build b/dom/performance/moz.build new file mode 100644 index 0000000000..8423932247 --- /dev/null +++ b/dom/performance/moz.build @@ -0,0 +1,65 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "DOM: Performance") + +EXPORTS.mozilla.dom += [ + "EventCounts.h", + "LargestContentfulPaint.h", + "Performance.h", + "PerformanceEntry.h", + "PerformanceEventTiming.h", + "PerformanceMainThread.h", + "PerformanceMark.h", + "PerformanceMeasure.h", + "PerformanceNavigation.h", + "PerformanceNavigationTiming.h", + "PerformanceObserver.h", + "PerformanceObserverEntryList.h", + "PerformancePaintTiming.h", + "PerformanceResourceTiming.h", + "PerformanceServerTiming.h", + "PerformanceService.h", + "PerformanceStorage.h", + "PerformanceStorageWorker.h", + "PerformanceTiming.h", + "PerformanceWorker.h", +] + +UNIFIED_SOURCES += [ + "EventCounts.cpp", + "LargestContentfulPaint.cpp", + "Performance.cpp", + "PerformanceEntry.cpp", + "PerformanceEventTiming.cpp", + "PerformanceMainThread.cpp", + "PerformanceMark.cpp", + "PerformanceMeasure.cpp", + "PerformanceNavigation.cpp", + "PerformanceNavigationTiming.cpp", + "PerformanceObserver.cpp", + "PerformanceObserverEntryList.cpp", + "PerformancePaintTiming.cpp", + "PerformanceResourceTiming.cpp", + "PerformanceServerTiming.cpp", + "PerformanceService.cpp", + "PerformanceStorageWorker.cpp", + "PerformanceTiming.cpp", + "PerformanceWorker.cpp", +] + +IPDL_SOURCES += [ + "PerformanceTimingTypes.ipdlh", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +MOCHITEST_MANIFESTS += ["tests/mochitest.toml"] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" diff --git a/dom/performance/tests/empty.js b/dom/performance/tests/empty.js new file mode 100644 index 0000000000..3b44754e30 --- /dev/null +++ b/dom/performance/tests/empty.js @@ -0,0 +1 @@ +/* Nothing here */ diff --git a/dom/performance/tests/logo.png b/dom/performance/tests/logo.png Binary files differnew file mode 100644 index 0000000000..a05926bcd7 --- /dev/null +++ b/dom/performance/tests/logo.png diff --git a/dom/performance/tests/mochitest.toml b/dom/performance/tests/mochitest.toml new file mode 100644 index 0000000000..198f8eb542 --- /dev/null +++ b/dom/performance/tests/mochitest.toml @@ -0,0 +1,67 @@ +[DEFAULT] +support-files = [ + "test_performance_observer.js", + "test_performance_user_timing.js", + "test_worker_performance_now.js", + "worker_performance_user_timing.js", + "worker_performance_observer.js", + "sharedworker_performance_user_timing.js", + "test_worker_performance_entries.js", + "test_worker_performance_entries.sjs", + "empty.js", + "serverTiming.sjs", +] + +["test_performance_navigation_timing.html"] + +["test_performance_observer.html"] + +["test_performance_paint_observer.html"] +support-files = [ + "test_performance_paint_observer_helper.html", + "logo.png", +] + +["test_performance_paint_timing.html"] +support-files = [ + "test_performance_paint_timing_helper.html", + "logo.png", +] + +["test_performance_server_timing.html"] +scheme = "https" +skip-if = [ + "http3", + "http2", +] + +["test_performance_server_timing_plain_http.html"] +skip-if = [ + "http3", + "http2", +] + +["test_performance_timing_json.html"] + +["test_performance_user_timing.html"] + +["test_performance_user_timing_dying_global.html"] + +["test_sharedWorker_performance_user_timing.html"] +skip-if = ["true"] # Bug 1571904 + +["test_timeOrigin.html"] +skip-if = ["os == 'android'"] # Bug 1525959 + +["test_worker_observer.html"] + +["test_worker_performance_entries.html"] +skip-if = [ + "os == 'android'", # Bug 1525959 + "http3", + "http2", +] + +["test_worker_performance_now.html"] + +["test_worker_user_timing.html"] diff --git a/dom/performance/tests/serverTiming.sjs b/dom/performance/tests/serverTiming.sjs new file mode 100644 index 0000000000..8a93829fa5 --- /dev/null +++ b/dom/performance/tests/serverTiming.sjs @@ -0,0 +1,41 @@ +var responseServerTiming = [ + { metric: "metric1", duration: "123.4", description: "description1" }, + { metric: "metric2", duration: "456.78", description: "description2" }, +]; +var trailerServerTiming = [ + { metric: "metric3", duration: "789.11", description: "description3" }, + { metric: "metric4", duration: "1112.13", description: "description4" }, +]; + +function createServerTimingHeader(headerData) { + var header = ""; + for (var i = 0; i < headerData.length; i++) { + header += + "Server-Timing:" + + headerData[i].metric + + ";" + + "dur=" + + headerData[i].duration + + ";" + + "desc=" + + headerData[i].description + + "\r\n"; + } + return header; +} + +function handleRequest(request, response) { + var body = "c\r\ndata reached\r\n3\r\nhej\r\n0\r\n"; + + response.seizePower(); + response.write("HTTP/1.1 200 OK\r\n"); + response.write("Content-Type: text/plain\r\n"); + response.write(createServerTimingHeader(responseServerTiming)); + + response.write("Transfer-Encoding: chunked\r\n"); + response.write("\r\n"); + response.write(body); + response.write(createServerTimingHeader(trailerServerTiming)); + response.write("\r\n"); + response.finish(); +} diff --git a/dom/performance/tests/sharedworker_performance_user_timing.js b/dom/performance/tests/sharedworker_performance_user_timing.js new file mode 100644 index 0000000000..6dcbd5d7d9 --- /dev/null +++ b/dom/performance/tests/sharedworker_performance_user_timing.js @@ -0,0 +1,38 @@ +var port; + +function ok(a, msg) { + dump("OK: " + !!a + " => " + a + " " + msg + "\n"); + port.postMessage({ type: "status", status: !!a, msg: a + ": " + msg }); +} + +function is(a, b, msg) { + dump("IS: " + (a === b) + " => " + a + " | " + b + " " + msg + "\n"); + port.postMessage({ + type: "status", + status: a === b, + msg: a + " === " + b + ": " + msg, + }); +} + +function isnot(a, b, msg) { + dump("ISNOT: " + (a === b) + " => " + a + " | " + b + " " + msg + "\n"); + port.postMessage({ + type: "status", + status: a != b, + msg: a + " != " + b + ": " + msg, + }); +} + +importScripts("test_performance_user_timing.js"); + +onconnect = function (evt) { + port = evt.ports[0]; + + for (var i = 0; i < steps.length; ++i) { + performance.clearMarks(); + performance.clearMeasures(); + steps[i](); + } + + port.postMessage({ type: "finish" }); +}; diff --git a/dom/performance/tests/test_performance_navigation_timing.html b/dom/performance/tests/test_performance_navigation_timing.html new file mode 100644 index 0000000000..abcf9fd340 --- /dev/null +++ b/dom/performance/tests/test_performance_navigation_timing.html @@ -0,0 +1,104 @@ +<!DOCTYPE HTML> +<html> + <!-- + https://bugzilla.mozilla.org/show_bug.cgi?id=1462891 + --> + <head> + <title>Test for Bug 1462891</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + </head> + <body> + <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1462891">Mozilla Bug 1462891 - Navigation Timing API</a> + <div id="content"> + </div> + <pre id="test"> + <script class="testbody" type="text/javascript"> + var index = 0; + let isRounded = (x, shouldRound, expectedPrecision) => { + if (!shouldRound) + return true; + + let rounded = (Math.floor(x / expectedPrecision) * expectedPrecision); + // First we do the perfectly normal check that should work just fine + if (rounded === x || x === 0) + return true; + + // When we're diving by non-whole numbers, we may not get perfect + // multiplication/division because of floating points. + // When dealing with ms since epoch, a double's precision is on the order + // of 1/5 of a microsecond, so we use a value a little higher than that as + // our epsilon. + // To be clear, this error is introduced in our re-calculation of 'rounded' + // above in JavaScript. + if (Math.abs(rounded - x + expectedPrecision) < .0005) { + return true; + } else if (Math.abs(rounded - x) < .0005) { + return true; + } + + // Then we handle the case where you're sub-millisecond and the timer is not + // We check that the timer is not sub-millisecond by assuming it is not if it + // returns an even number of milliseconds + if (expectedPrecision < 1 && Math.round(x) == x) { + if (Math.round(rounded) == x) { + return true; + } + } + + ok(false, "Looming Test Failure, Additional Debugging Info: Expected Precision: " + expectedPrecision + " Measured Value: " + x + + " Rounded Vaue: " + rounded + " Fuzzy1: " + Math.abs(rounded - x + expectedPrecision) + + " Fuzzy 2: " + Math.abs(rounded - x)); + + return false; + }; + + var metrics = [ + "unloadEventStart", + "unloadEventEnd", + "domInteractive", + "domContentLoadedEventStart", + "domContentLoadedEventEnd", + "domComplete", + "loadEventStart", + "loadEventEnd" + ]; + + async function runTests(resistFingerprinting, reduceTimerPrecision, expectedPrecision) { + await SpecialPowers.pushPrefEnv({ + "set": [["privacy.resistFingerprinting", resistFingerprinting], + ["privacy.reduceTimerPrecision", reduceTimerPrecision], + ["privacy.resistFingerprinting.reduceTimerPrecision.microseconds", expectedPrecision * 1000] + ]}); + var entries = performance.getEntriesByType("navigation"); + is(entries.length, 1, "Checking PerformanceNavigationEntry count"); + + for (let i=0; i<entries.length; i++) { + for (let j=0; j<metrics.length; j++) { + ok(isRounded(entries[i][metrics[j]], reduceTimerPrecision, expectedPrecision), + "Testing " + metrics[j] + " with value " + entries[i][metrics[j]] + + " with resistFingerprinting " + resistFingerprinting + " reduceTimerPrecision " + + reduceTimerPrecision + " precision " + expectedPrecision); + } + } + } + + async function startTests() { + await runTests(false, false, 2); + await runTests(true, false, 2); + await runTests(true, true, 2); + await runTests(false, true, 1000); + await runTests(false, true, 133); + await runTests(false, true, 13); + await runTests(false, true, 2); + await runTests(false, true, 1); + + SimpleTest.finish(); + } + + SimpleTest.waitForExplicitFinish(); + addLoadEvent(startTests); + </script> + </pre> + </body> +</html> diff --git a/dom/performance/tests/test_performance_observer.html b/dom/performance/tests/test_performance_observer.html new file mode 100644 index 0000000000..86c780c56c --- /dev/null +++ b/dom/performance/tests/test_performance_observer.html @@ -0,0 +1,142 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<html> +<head> +<meta charset=utf-8> +<title>Test for performance observer</title> +<script src="/tests/SimpleTest/SimpleTest.js"></script> +<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<div id="log"></div> +<script> +SimpleTest.requestFlakyTimeout("For testing when observer callbacks should not be called."); +SimpleTest.waitForExplicitFinish(); + +let _tests = []; + +let test = promise_test = fn => { + let cleanups = []; + _tests.push(async () => { + try { + await fn({ + add_cleanup: f => { cleanups.push(f); }, + step_timeout(f, timeout) { + var test_this = this; + var args = Array.prototype.slice.call(arguments, 2); + return setTimeout(() => { + return f.apply(test_this, args); + }, timeout); + } + }); + } catch(e) { + ok(false, `got unexpected exception ${e}`); + } + try { + for (const f of cleanups) { + f(); + } + runNextTest(); + } catch (e) { + ok(false, `got unexpected exception during cleanup ${e}`); + } + }); +} + +function runNextTest() { + if (!_tests.length) { + SimpleTest.finish() + return; + } + _tests.shift()(); +} + +function assert_equals(actual, expected, description) { + ok(typeof actual == typeof expected, + `${description} expected (${typeof expected}) ${expected} but got (${typeof actual}) ${actual}`); + ok(Object.is(actual, expected), + `${description} expected ${expected} but got ${actual}`); +} + +function assert_array_equals(actual, expected, description) { + ok(actual.length === expected.length, + `${description} lengths differ, expected ${expected.length} but got ${actual.length}`); + for (var i = 0; i < actual.length; i++) { + ok(actual.hasOwnProperty(i) === expected.hasOwnProperty(i), + `${description} property expected to be ${expected[i]} but got ${actual[i]}`); + } +} + +function assert_throws(expected_exc, func, desc) { + try { + func.call(this); + } catch(e) { + var actual = e.name || e.type; + var expected = expected_exc.name || expected_exc.type; + ok(actual == expected, + `Expected '${expected}', got '${actual}'.`); + return; + } + ok(false, "Expected exception, but none was thrown"); +} + +function assert_unreached(description) { + ok(false, `${description} reached unreachable code`); +} +</script> +<script src="test_performance_observer.js"></script> +<script> +function makeXHR(aUrl) { + var xmlhttp = new XMLHttpRequest(); + xmlhttp.open("get", aUrl, true); + xmlhttp.send(); +} + +let waitForConsole = new Promise(resolve => { + SimpleTest.monitorConsole(resolve, [{ + message: /JavaScript Warning: "Ignoring unsupported entryTypes: invalid."/, + }]); +}); + +promise_test(t => { + var promise = new Promise(resolve => { + performance.clearResourceTimings(); + + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe({entryTypes: ['resource']}); + t.add_cleanup(() => observer.disconnect()); + }); + + makeXHR("test-data.json"); + + return promise.then(async list => { + assert_equals(list.getEntries().length, 1); + assert_array_equals(list.getEntries(), + performance.getEntriesByType("resource"), + "Observed 'resource' entries should equal to entries obtained by getEntriesByType."); + + // getEntries filtering tests + assert_array_equals(list.getEntries({name: "http://mochi.test:8888/tests/dom/base/test/test-data.json"}), + performance.getEntriesByName("http://mochi.test:8888/tests/dom/base/test/test-data.json"), + "getEntries with name filter should return correct results."); + assert_array_equals(list.getEntries({entryType: "resource"}), + performance.getEntriesByType("resource"), + "getEntries with entryType filter should return correct results."); + assert_array_equals(list.getEntries({initiatorType: "xmlhttprequest"}), + performance.getEntriesByType("resource"), + "getEntries with initiatorType filter should return correct results."); + assert_array_equals(list.getEntries({initiatorType: "link"}), + [], + "getEntries with non-existent initiatorType filter should return an empty array."); + + SimpleTest.endMonitorConsole(); + await waitForConsole; + }); +}, "resource-timing test"); + +runNextTest(); +</script> +</body> diff --git a/dom/performance/tests/test_performance_observer.js b/dom/performance/tests/test_performance_observer.js new file mode 100644 index 0000000000..ddc57d4096 --- /dev/null +++ b/dom/performance/tests/test_performance_observer.js @@ -0,0 +1,286 @@ +test(t => { + assert_throws( + { name: "TypeError" }, + function () { + new PerformanceObserver(); + }, + "PerformanceObserver constructor should throw TypeError if no argument is specified." + ); + + assert_throws( + { name: "TypeError" }, + function () { + new PerformanceObserver({}); + }, + "PerformanceObserver constructor should throw TypeError if the argument is not a function." + ); +}, "Test that PerformanceObserver constructor throws exception"); + +test(t => { + var observer = new PerformanceObserver(() => {}); + + assert_throws( + { name: "TypeError" }, + function () { + observer.observe(); + }, + "observe() should throw TypeError exception if no option specified." + ); + + assert_throws( + { name: "TypeError" }, + function () { + observer.observe({ unsupportedAttribute: "unsupported" }); + }, + "obsrve() should throw TypeError exception if the option has no 'entryTypes' attribute." + ); + + assert_equals( + undefined, + observer.observe({ entryTypes: [] }), + "observe() should silently ignore empty 'entryTypes' sequence." + ); + + assert_throws( + { name: "TypeError" }, + function () { + observer.observe({ entryTypes: null }); + }, + "obsrve() should throw TypeError exception if 'entryTypes' attribute is null." + ); + + assert_equals( + undefined, + observer.observe({ entryTypes: ["invalid"] }), + "observe() should silently ignore invalid 'entryTypes' values." + ); +}, "Test that PerformanceObserver.observe throws exception"); + +function promiseObserve(test, options) { + return new Promise(resolve => { + performance.clearMarks(); + performance.clearMeasures(); + + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe(options); + test.add_cleanup(() => observer.disconnect()); + }); +} + +promise_test(t => { + var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] }); + + performance.mark("test-start"); + performance.mark("test-end"); + performance.measure("test-measure", "test-start", "test-end"); + + return promise.then(list => { + assert_equals( + list.getEntries().length, + 3, + "There should be three observed entries." + ); + + var markEntries = list.getEntries().filter(entry => { + return entry.entryType == "mark"; + }); + assert_array_equals( + markEntries, + performance.getEntriesByType("mark"), + "Observed 'mark' entries should equal to entries obtained by getEntriesByType." + ); + + var measureEntries = list.getEntries().filter(entry => { + return entry.entryType == "measure"; + }); + assert_array_equals( + measureEntries, + performance.getEntriesByType("measure"), + "Observed 'measure' entries should equal to entries obtained by getEntriesByType." + ); + }); +}, "Test for user-timing with PerformanceObserver"); + +promise_test(t => { + var promise = new Promise((resolve, reject) => { + performance.clearMarks(); + performance.clearMeasures(); + + var observer = new PerformanceObserver(list => reject(list)); + observer.observe({ entryTypes: ["mark", "measure"] }); + observer.disconnect(); + t.step_timeout(resolve, 100); + }); + + performance.mark("test-start"); + performance.mark("test-end"); + performance.measure("test-measure", "test-start", "test-end"); + + return promise.then( + () => { + assert_equals(performance.getEntriesByType("mark").length, 2); + assert_equals(performance.getEntriesByType("measure").length, 1); + }, + list => { + assert_unreached("Observer callback should never be called."); + } + ); +}, "Nothing should be notified after disconnecting observer"); + +promise_test(t => { + var promise = promiseObserve(t, { entryTypes: ["mark"] }); + + performance.mark("test"); + + return promise.then(list => { + assert_array_equals( + list.getEntries({ entryType: "mark" }), + performance.getEntriesByType("mark"), + "getEntries with entryType filter should return correct results." + ); + + assert_array_equals( + list.getEntries({ name: "test" }), + performance.getEntriesByName("test"), + "getEntries with name filter should return correct results." + ); + + assert_array_equals( + list.getEntries({ name: "test", entryType: "mark" }), + performance.getEntriesByName("test"), + "getEntries with name and entryType filter should return correct results." + ); + + assert_array_equals( + list.getEntries({ name: "invalid" }), + [], + "getEntries with non-existent name filter should return an empty array." + ); + + assert_array_equals( + list.getEntries({ name: "test", entryType: "measure" }), + [], + "getEntries with name filter and non-existent entryType should return an empty array." + ); + + assert_array_equals( + list.getEntries({ name: "invalid", entryType: "mark" }), + [], + "getEntries with non-existent name and entryType filter should return an empty array." + ); + + assert_array_equals( + list.getEntries({ initiatorType: "xmlhttprequest" }), + [], + "getEntries with initiatorType filter should return an empty array." + ); + }); +}, "Test for PerformanceObserverEntryList.getEntries"); + +promise_test(t => { + var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] }); + + performance.mark("test"); + performance.measure("test-measure", "test", "test"); + + return promise.then(list => { + assert_array_equals( + list.getEntriesByType("mark"), + performance.getEntriesByType("mark") + ); + assert_array_equals( + list.getEntriesByType("measure"), + performance.getEntriesByType("measure") + ); + }); +}, "Test for PerformanceObserverEntryList.getEntriesByType"); + +promise_test(t => { + var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] }); + + performance.mark("test"); + performance.measure("test-measure", "test", "test"); + + return promise.then(list => { + assert_array_equals( + list.getEntriesByName("test"), + performance.getEntriesByName("test") + ); + assert_array_equals( + list.getEntriesByName("test-measure"), + performance.getEntriesByName("test-measure") + ); + }); +}, "Test for PerformanceObserverEntryList.getEntriesByName"); + +promise_test(t => { + var promise = new Promise(resolve => { + performance.clearMarks(); + performance.clearMeasures(); + + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe({ entryTypes: ["mark", "measure"] }); + observer.observe({ entryTypes: ["mark", "measure"] }); + t.add_cleanup(() => observer.disconnect()); + }); + + performance.mark("test-start"); + performance.mark("test-end"); + performance.measure("test-measure", "test-start", "test-end"); + + return promise.then(list => { + assert_equals( + list.getEntries().length, + 3, + "Observed user timing entries should have only three entries." + ); + }); +}, "Test that invoking observe method twice affects nothing"); + +promise_test(t => { + var promise = new Promise(resolve => { + performance.clearMarks(); + performance.clearMeasures(); + + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe({ entryTypes: ["mark", "measure"] }); + observer.observe({ entryTypes: ["mark"] }); + t.add_cleanup(() => observer.disconnect()); + }); + + performance.mark("test-start"); + performance.mark("test-end"); + performance.measure("test-measure", "test-start", "test-end"); + + return promise.then(list => { + assert_equals( + list.getEntries().length, + 2, + "Observed user timing entries should have only two entries." + ); + }); +}, "Test that observing filter is replaced by a new filter"); + +promise_test(t => { + var promise = new Promise(resolve => { + performance.clearMarks(); + performance.clearMeasures(); + + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe({ entryTypes: ["mark"] }); + observer.observe({ entryTypes: ["measure"] }); + t.add_cleanup(() => observer.disconnect()); + }); + + performance.mark("test-start"); + performance.mark("test-end"); + performance.measure("test-measure", "test-start", "test-end"); + + return promise.then(list => { + assert_equals( + list.getEntries().length, + 1, + "Observed user timing entries should have only 1 entries." + ); + }); +}, "Test that observing filter is replaced by a new filter"); diff --git a/dom/performance/tests/test_performance_paint_observer.html b/dom/performance/tests/test_performance_paint_observer.html new file mode 100644 index 0000000000..2ded1db797 --- /dev/null +++ b/dom/performance/tests/test_performance_paint_observer.html @@ -0,0 +1,40 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <!-- + https://bugzilla.mozilla.org/show_bug.cgi?id=1518999 + --> + <head> + <title>Test for Bug 1518999 (Observer API) </title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <a target="_blank" + href="https://bugzilla.mozilla.org/show_bug.cgi?id=1518999">Mozilla + Bug 1518999 - Paint Timing API For Observers</a> + <p id="display"></p> + <div id="content" style="display: none"> + <pre id="test"> + <script class="testbody" type="text/javascript"> + let tab; + function runTest() { + tab = window.open("test_performance_paint_observer_helper.html"); + } + + function done() { + tab.close(); + SimpleTest.finish(); + } + + SimpleTest.waitForExplicitFinish(); + addLoadEvent(runTest); + </script> + </pre> + </div> + </body> +</html> diff --git a/dom/performance/tests/test_performance_paint_observer_helper.html b/dom/performance/tests/test_performance_paint_observer_helper.html new file mode 100644 index 0000000000..ae27c9480d --- /dev/null +++ b/dom/performance/tests/test_performance_paint_observer_helper.html @@ -0,0 +1,35 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<html> + <body> + </body> + <script> + var promise = new Promise(resolve => { + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe({entryTypes: ["paint"]}); + }); + + promise.then(list => { + var perfEntries = list.getEntries(); + opener.is(list.getEntries().length, 1); + opener.isDeeply(list.getEntries(), + performance.getEntriesByType("paint"), + "Observed 'paint' entries should equal to entries obtained by getEntriesByType."); + opener.isDeeply(list.getEntries({name: "paint"}), + performance.getEntriesByName("paint"), + "getEntries with name filter should return correct results."); + opener.isDeeply(list.getEntries({entryType: "paint"}), + performance.getEntriesByType("paint"), + "getEntries with entryType filter should return correct results."); + opener.done(); + }); + + const img = document.createElement("IMG"); + img.src = "http://example.org/tests/dom/performance/tests/logo.png"; + document.body.appendChild(img); + + </script> +</html> diff --git a/dom/performance/tests/test_performance_paint_timing.html b/dom/performance/tests/test_performance_paint_timing.html new file mode 100644 index 0000000000..f8784ecf26 --- /dev/null +++ b/dom/performance/tests/test_performance_paint_timing.html @@ -0,0 +1,38 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <!-- + https://bugzilla.mozilla.org/show_bug.cgi?id=1518999 + --> + <head> + <title>Test for Bug 1518999</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + </head> + <body> + <a target="_blank" + href="https://bugzilla.mozilla.org/show_bug.cgi?id=1518999">Mozilla + Bug 1518999 - Paint Timing API</a> + <p id="display"></p> + <div id="content" style="display: none"> + <pre id="test"> + <script class="testbody" type="text/javascript"> + let tab; + function runTest() { + tab = window.open("test_performance_paint_timing_helper.html"); + } + function done() { + tab.close(); + SimpleTest.finish(); + } + SimpleTest.waitForExplicitFinish(); + addLoadEvent(runTest); + </script> + </pre> + </div> + </body> +</html> diff --git a/dom/performance/tests/test_performance_paint_timing_helper.html b/dom/performance/tests/test_performance_paint_timing_helper.html new file mode 100644 index 0000000000..c05b38cac0 --- /dev/null +++ b/dom/performance/tests/test_performance_paint_timing_helper.html @@ -0,0 +1,65 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <!-- + https://bugzilla.mozilla.org/show_bug.cgi?id=1518999 + --> + <head> + <title>Test for Bug 1518999</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + </head> + <body> + <div id="main"></div> + <div id="image"></div> + <div id="test"> + <script class="testbody" type="text/javascript"> + async function runTest() { + const paintEntries = performance.getEntriesByType('paint'); + opener.is(paintEntries.length, 0, "No paint entries yet"); + + const img = document.createElement("img"); + img.src = "http://example.org/tests/dom/performance/tests/logo.png"; + + img.onload = function() { + function getAndTestEntries(runCount) { + function testEntries(entries) { + opener.is(entries.length, 1, "FCP Only returns"); + opener.is(entries[0].entryType, "paint", "entryType is paint"); + opener.is(entries[0].name, "first-contentful-paint", + "Returned entry should be first-contentful-paint" ); + const fcpEntriesGotByName = + performance.getEntriesByName('first-contentful-paint'); + opener.is(fcpEntriesGotByName.length, 1, "entries length should match"); + opener.is(entries[0], fcpEntriesGotByName[0], "should be the same entry"); + opener.done(); + } + const entries = performance.getEntriesByType('paint'); + if (entries.length < 1) { + if (runCount < 4) { + opener.SimpleTest.requestFlakyTimeout("FCP is being registered asynchronously, so wait a bit of time"); + setTimeout(function() { + getAndTestEntries(runCount + 1); + }, 20); + } else { + opener.ok(false, "Unable to find paint entries within a reasonable amount of time"); + opener.done(); + } + } else { + testEntries(entries); + } + } + getAndTestEntries(1); + } + document.body.appendChild(img); + } + window.onload = function() { + runTest(); + } + </script> + </div> + </div> + </body> +</html> diff --git a/dom/performance/tests/test_performance_server_timing.html b/dom/performance/tests/test_performance_server_timing.html new file mode 100644 index 0000000000..cba11a5fdd --- /dev/null +++ b/dom/performance/tests/test_performance_server_timing.html @@ -0,0 +1,58 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<html> +<head> +<meta charset=utf-8> +<title>Test for PerformanceServerTiming</title> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +</head> +<body> +<div id="log"></div> +<script> +function makeXHR(aUrl) { + var xmlhttp = new XMLHttpRequest(); + xmlhttp.open("get", aUrl, true); + xmlhttp.send(); +} + +// Note that |responseServerTiming| and |trailerServerTiming| SHOULD be synced with +// the ones in serverTiming.sjs. +var responseServerTiming = [{metric:"metric1", duration:"123.4", description:"description1"}, + {metric:"metric2", duration:"456.78", description:"description2"}]; +var trailerServerTiming = [{metric:"metric3", duration:"789.11", description:"description3"}, + {metric:"metric4", duration:"1112.13", description:"description4"}]; + +function checkServerTimingContent(serverTiming) { + var expectedResult = responseServerTiming.concat(trailerServerTiming); + assert_equals(serverTiming.length, expectedResult.length); + + for (var i = 0; i < expectedResult.length; i++) { + assert_equals(serverTiming[i].name, expectedResult[i].metric); + assert_equals(serverTiming[i].description, expectedResult[i].description); + assert_equals(serverTiming[i].duration, parseFloat(expectedResult[i].duration)); + } +} + +promise_test(t => { + var promise = new Promise(resolve => { + performance.clearResourceTimings(); + + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe({entryTypes: ['resource']}); + t.add_cleanup(() => observer.disconnect()); + }); + + makeXHR("serverTiming.sjs"); + + return promise.then(list => { + assert_equals(list.getEntries().length, 1); + checkServerTimingContent(list.getEntries()[0].serverTiming); + }); +}, "server-timing test"); + +</script> +</body> diff --git a/dom/performance/tests/test_performance_server_timing_plain_http.html b/dom/performance/tests/test_performance_server_timing_plain_http.html new file mode 100644 index 0000000000..7dcb8bd38d --- /dev/null +++ b/dom/performance/tests/test_performance_server_timing_plain_http.html @@ -0,0 +1,42 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<html> +<head> +<meta charset=utf-8> +<title>Plain HTTP Test for PerformanceServerTiming</title> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +</head> +<body> +<div id="log"></div> +<script> +function makeXHR(aUrl) { + var xmlhttp = new XMLHttpRequest(); + xmlhttp.open("get", aUrl, true); + xmlhttp.send(); +} + +promise_test(t => { + var promise = new Promise(resolve => { + performance.clearResourceTimings(); + + var observer = new PerformanceObserver(list => resolve(list)); + observer.observe({entryTypes: ['resource']}); + t.add_cleanup(() => observer.disconnect()); + }); + + makeXHR("serverTiming.sjs"); + + return promise.then(list => { + assert_equals(list.getEntries().length, 1); + assert_equals(list.getEntries()[0].serverTiming, undefined); + assert_equals(list.getEntries()[0].toJSON().serverTiming, undefined, + "toJSON should not pick up properties that aren't on the object"); + }); +}, "server-timing test"); + +</script> +</body> diff --git a/dom/performance/tests/test_performance_timing_json.html b/dom/performance/tests/test_performance_timing_json.html new file mode 100644 index 0000000000..97079c0d2f --- /dev/null +++ b/dom/performance/tests/test_performance_timing_json.html @@ -0,0 +1,32 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1375829 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1375829</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript"> + + /** Test for Bug 1375829 **/ + var json = performance.timing.toJSON(); + + // Ensure it doesn't have any attributes that performance.timing doesn't have + for (let key of Object.keys(json)) { + ok(key in performance.timing, key + " should be a property of performance.timing"); + } + + </script> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1375829">Mozilla Bug 1375829</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +</pre> +</body> +</html> diff --git a/dom/performance/tests/test_performance_user_timing.html b/dom/performance/tests/test_performance_user_timing.html new file mode 100644 index 0000000000..fa0aaceb4e --- /dev/null +++ b/dom/performance/tests/test_performance_user_timing.html @@ -0,0 +1,49 @@ +<!DOCTYPE HTML> +<html> + <!-- + https://bugzilla.mozilla.org/show_bug.cgi?id=782751 + --> + <head> + <title>Test for Bug 782751</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="test_performance_user_timing.js"></script> + </head> + <body> + <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=782751">Mozilla Bug 782751 - User Timing API</a> + <div id="content"> + </div> + <pre id="test"> + <script class="testbody" type="text/javascript"> + var index = 0; + + function next() { + ok(true, "Begin!"); + var arr; + for (var i = 0; i < steps.length; ++i) { + try { + performance.clearMarks(); + performance.clearMeasures(); + performance.clearResourceTimings(); + is(performance.getEntriesByType("resource").length, 0, "clearing performance resource entries"); + is(performance.getEntriesByType("mark").length, 0, "clearing performance mark entries"); + is(performance.getEntriesByType("measure").length, 0, "clearing performance measure entries"); + steps[i](); + } catch(ex) { + ok(false, "Caught exception", ex); + } + } + + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", reduceTimePrecisionPrevPrefValue); + SimpleTest.finish(); + } + + var reduceTimePrecisionPrevPrefValue = SpecialPowers.getBoolPref("privacy.reduceTimerPrecision"); + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", false); + + SimpleTest.waitForExplicitFinish(); + addLoadEvent(next); + </script> + </pre> + </body> +</html> diff --git a/dom/performance/tests/test_performance_user_timing.js b/dom/performance/tests/test_performance_user_timing.js new file mode 100644 index 0000000000..c98bee6f11 --- /dev/null +++ b/dom/performance/tests/test_performance_user_timing.js @@ -0,0 +1,318 @@ +var steps = [ + // Test single mark addition + function () { + ok(true, "Running mark addition test"); + performance.mark("test"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 1, "Number of marks should be 1"); + var mark = marks[0]; + is(mark.name, "test", "mark name should be 'test'"); + is(mark.entryType, "mark", "mark type should be 'mark'"); + isnot(mark.startTime, 0, "mark start time should not be 0"); + is(mark.duration, 0, "mark duration should be 0"); + }, + // Test multiple mark addition + function () { + ok(true, "Running multiple mark with same name addition test"); + performance.mark("test"); + performance.mark("test"); + performance.mark("test"); + var marks_type = performance.getEntriesByType("mark"); + is(marks_type.length, 3, "Number of marks by type should be 3"); + var marks_name = performance.getEntriesByName("test"); + is(marks_name.length, 3, "Number of marks by name should be 3"); + var mark = marks_name[0]; + is(mark.name, "test", "mark name should be 'test'"); + is(mark.entryType, "mark", "mark type should be 'mark'"); + isnot(mark.startTime, 0, "mark start time should not be 0"); + is(mark.duration, 0, "mark duration should be 0"); + var times = []; + // This also tests the chronological ordering specified as + // required for getEntries in the performance timeline spec. + marks_name.forEach(function (s) { + times.forEach(function (time) { + ok( + s.startTime >= time.startTime, + "Times should be equal or increasing between similarly named marks: " + + s.startTime + + " >= " + + time.startTime + ); + }); + times.push(s); + }); + }, + // Test all marks removal + function () { + ok(true, "Running all mark removal test"); + performance.mark("test"); + performance.mark("test2"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 2, "number of marks before all removal"); + performance.clearMarks(); + marks = performance.getEntriesByType("mark"); + is(marks.length, 0, "number of marks after all removal"); + }, + // Test single mark removal + function () { + ok(true, "Running removal test (0 'test' marks with other marks)"); + performance.mark("test2"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 1, "number of marks before all removal"); + performance.clearMarks("test"); + marks = performance.getEntriesByType("mark"); + is(marks.length, 1, "number of marks after all removal"); + }, + // Test single mark removal + function () { + ok(true, "Running removal test (0 'test' marks with no other marks)"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 0, "number of marks before all removal"); + performance.clearMarks("test"); + marks = performance.getEntriesByType("mark"); + is(marks.length, 0, "number of marks after all removal"); + }, + function () { + ok(true, "Running removal test (1 'test' mark with other marks)"); + performance.mark("test"); + performance.mark("test2"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 2, "number of marks before all removal"); + performance.clearMarks("test"); + marks = performance.getEntriesByType("mark"); + is(marks.length, 1, "number of marks after all removal"); + }, + function () { + ok(true, "Running removal test (1 'test' mark with no other marks)"); + performance.mark("test"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 1, "number of marks before all removal"); + performance.clearMarks("test"); + marks = performance.getEntriesByType("mark"); + is(marks.length, 0, "number of marks after all removal"); + }, + function () { + ok(true, "Running removal test (2 'test' marks with other marks)"); + performance.mark("test"); + performance.mark("test"); + performance.mark("test2"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 3, "number of marks before all removal"); + performance.clearMarks("test"); + marks = performance.getEntriesByType("mark"); + is(marks.length, 1, "number of marks after all removal"); + }, + function () { + ok(true, "Running removal test (2 'test' marks with no other marks)"); + performance.mark("test"); + performance.mark("test"); + var marks = performance.getEntriesByType("mark"); + is(marks.length, 2, "number of marks before all removal"); + performance.clearMarks("test"); + marks = performance.getEntriesByType("mark"); + is(marks.length, 0, "number of marks after all removal"); + }, + // Test mark name being same as navigation timing parameter + function () { + ok(true, "Running mark name collision test"); + for (n in performance.timing) { + try { + if (n == "toJSON") { + ok(true, "Skipping toJSON entry in collision test"); + continue; + } + performance.mark(n); + ok( + false, + "Mark name collision test failed for name " + + n + + ", shouldn't make it here!" + ); + } catch (e) { + ok( + e instanceof DOMException, + "DOM exception thrown for mark named " + n + ); + is( + e.code, + e.SYNTAX_ERR, + "DOM exception for name collision is syntax error" + ); + } + } + }, + // Test measure + function () { + ok(true, "Running measure addition with no start/end time test"); + performance.measure("test"); + var measures = performance.getEntriesByType("measure"); + is(measures.length, 1, "number of measures should be 1"); + var measure = measures[0]; + is(measure.name, "test", "measure name should be 'test'"); + is(measure.entryType, "measure", "measure type should be 'measure'"); + is(measure.startTime, 0, "measure start time should be zero"); + ok(measure.duration >= 0, "measure duration should not be negative"); + }, + function () { + ok(true, "Running measure addition with only start time test"); + performance.mark("test1"); + performance.measure("test", "test1", undefined); + var measures = performance.getEntriesByName("test", "measure"); + var marks = performance.getEntriesByName("test1", "mark"); + var measure = measures[0]; + var mark = marks[0]; + is( + measure.startTime, + mark.startTime, + "measure start time should be equal to the mark startTime" + ); + ok(measure.duration >= 0, "measure duration should not be negative"); + }, + function () { + ok(true, "Running measure addition with only end time test"); + performance.mark("test1"); + performance.measure("test", undefined, "test1"); + var measures = performance.getEntriesByName("test", "measure"); + var marks = performance.getEntriesByName("test1", "mark"); + var measure = measures[0]; + var mark = marks[0]; + ok(measure.duration >= 0, "measure duration should not be negative"); + }, + // Test measure picking latest version of similarly named tags + function () { + ok(true, "Running multiple mark with same name addition test"); + performance.mark("test"); + performance.mark("test"); + performance.mark("test"); + performance.mark("test2"); + var marks_name = performance.getEntriesByName("test"); + is(marks_name.length, 3, "Number of marks by name should be 3"); + var marks_name2 = performance.getEntriesByName("test2"); + is(marks_name2.length, 1, "Number of marks by name should be 1"); + var test_mark = marks_name2[0]; + performance.measure("test", "test", "test2"); + var measures_type = performance.getEntriesByType("measure"); + var last_mark = marks_name[marks_name.length - 1]; + is(measures_type.length, 1, "Number of measures by type should be 1"); + var measure = measures_type[0]; + is( + measure.startTime, + last_mark.startTime, + "Measure start time should be the start time of the latest 'test' mark" + ); + // Tolerance testing to avoid oranges, since we're doing double math across two different languages. + ok( + measure.duration - (test_mark.startTime - last_mark.startTime) < 0.00001, + "Measure duration ( " + + measure.duration + + ") should be difference between two marks" + ); + }, + function () { + // We don't have navigationStart in workers. + if ("window" in self) { + ok(true, "Running measure addition with no start/end time test"); + performance.measure("test", "navigationStart"); + var measures = performance.getEntriesByType("measure"); + is(measures.length, 1, "number of measures should be 1"); + var measure = measures[0]; + is(measure.name, "test", "measure name should be 'test'"); + is(measure.entryType, "measure", "measure type should be 'measure'"); + is(measure.startTime, 0, "measure start time should be zero"); + ok(measure.duration >= 0, "measure duration should not be negative"); + } + }, + // Test all measure removal + function () { + ok(true, "Running all measure removal test"); + performance.measure("test"); + performance.measure("test2"); + var measures = performance.getEntriesByType("measure"); + is(measures.length, 2, "measure entries should be length 2"); + performance.clearMeasures(); + measures = performance.getEntriesByType("measure"); + is(measures.length, 0, "measure entries should be length 0"); + }, + // Test single measure removal + function () { + ok(true, "Running all measure removal test"); + performance.measure("test"); + performance.measure("test2"); + var measures = performance.getEntriesByType("measure"); + is(measures.length, 2, "measure entries should be length 2"); + performance.clearMeasures("test"); + measures = performance.getEntriesByType("measure"); + is(measures.length, 1, "measure entries should be length 1"); + }, + // Test measure with invalid start time mark name + function () { + ok(true, "Running measure invalid start test"); + try { + performance.measure("test", "notamark"); + ok(false, "invalid measure start time exception not thrown!"); + } catch (e) { + ok(e instanceof DOMException, "DOM exception thrown for invalid measure"); + is( + e.code, + e.SYNTAX_ERR, + "DOM exception for invalid time is syntax error" + ); + } + }, + // Test measure with invalid end time mark name + function () { + ok(true, "Running measure invalid end test"); + try { + performance.measure("test", undefined, "notamark"); + ok(false, "invalid measure end time exception not thrown!"); + } catch (e) { + ok(e instanceof DOMException, "DOM exception thrown for invalid measure"); + is( + e.code, + e.SYNTAX_ERR, + "DOM exception for invalid time is syntax error" + ); + } + }, + // Test measure name being same as navigation timing parameter + function () { + ok(true, "Running measure name collision test"); + for (n in performance.timing) { + if (n == "toJSON") { + ok(true, "Skipping toJSON entry in collision test"); + continue; + } + performance.measure(n); + ok(true, "Measure name supports name collisions: " + n); + } + }, + // Test measure mark being a reserved name + function () { + ok(true, "Create measures using all reserved names"); + for (n in performance.timing) { + try { + if (n == "toJSON") { + ok(true, "Skipping toJSON entry in collision test"); + continue; + } + performance.measure("test", n); + ok(true, "Measure created from reserved name as starting time: " + n); + } catch (e) { + ok( + [ + "redirectStart", + "redirectEnd", + "unloadEventStart", + "unloadEventEnd", + "loadEventEnd", + "secureConnectionStart", + ].includes(n), + "Measure created from reserved name as starting time: " + + n + + " and threw expected error" + ); + } + } + }, + // TODO: Test measure picking latest version of similarly named tags +]; diff --git a/dom/performance/tests/test_performance_user_timing_dying_global.html b/dom/performance/tests/test_performance_user_timing_dying_global.html new file mode 100644 index 0000000000..18e4a54684 --- /dev/null +++ b/dom/performance/tests/test_performance_user_timing_dying_global.html @@ -0,0 +1,61 @@ +<!DOCTYPE html> +<html> + <head> + <title>Test for User Timing APIs on dying globals</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript"> + // We must wait for the iframe to load. + SimpleTest.waitForExplicitFinish(); + window.addEventListener('load', () => { + const dyingWindow = initTest(); + ok(true, 'Initialization complete'); + + testDoesNotCrash(dyingWindow); + SimpleTest.finish(); + }); + + function initTest() { + // We create a dying global by creating an iframe, keeping a + // reference to it, and removing it. + const iframe = document.querySelector('iframe'); + const iframeWindow = iframe.contentWindow; + + // We want to call the User Timing functions in the context of + // the dying global. However, we can't call constructors + // directly on a reference to a window so we have to wrap it. + iframeWindow.newPerformanceMark = () => { + new PerformanceMark('constructor', {detail: 'constructorDetail'}); + }; + + // Send the global to a dying state. + iframe.remove(); + + return iframeWindow; + } + + function testDoesNotCrash(dyingWindow) { + ok(true, 'Running testDoesNotCrash'); + + dyingWindow.newPerformanceMark(); + ok(true, 'new PerformanceMark() on dying global did not crash'); + + try { + dyingWindow.performance.mark('markMethod', {detail: 'markMethodDetail'}); + } catch (e) { + is(e.code, e.INVALID_STATE_ERR, 'performance.mark on dying global threw expected exception'); + } + ok(true, 'performance.mark on dying global did not crash'); + + try { + dyingWindow.performance.measure('measureMethod'); + } catch (e) { + is(e.code, e.INVALID_STATE_ERR, 'performance.measure on dying global threw expected exception'); + } + ok(true, 'performance.measure on dying global did not crash'); + } + </script> + </head> + <body> + <iframe width="200" height="200" src="about:blank"></iframe> + </body> +</html> diff --git a/dom/performance/tests/test_sharedWorker_performance_user_timing.html b/dom/performance/tests/test_sharedWorker_performance_user_timing.html new file mode 100644 index 0000000000..d26594e292 --- /dev/null +++ b/dom/performance/tests/test_sharedWorker_performance_user_timing.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for worker performance timing API</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + </head> + <body> + <script class="testbody" type="text/javascript"> + +var sw = new SharedWorker('sharedworker_performance_user_timing.js'); +sw.port.onmessage = function(event) { + if (event.data.type == 'finish') { + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", reduceTimePrecisionPrevPrefValue); + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } +} + +var reduceTimePrecisionPrevPrefValue = SpecialPowers.getBoolPref("privacy.reduceTimerPrecision"); +SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", false); +SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> diff --git a/dom/performance/tests/test_timeOrigin.html b/dom/performance/tests/test_timeOrigin.html new file mode 100644 index 0000000000..69796a432d --- /dev/null +++ b/dom/performance/tests/test_timeOrigin.html @@ -0,0 +1,76 @@ +<!DOCTYPE HTML> +<html> + <head> + <title>Test for performance.timeOrigin</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + </head> + <body> + <script type="text/js-worker" id="worker-src"> + postMessage({ now: performance.now(), timeOrigin: performance.timeOrigin }); + </script> + + <script type="text/js-worker" id="shared-worker-src"> + onconnect = function(evt) { + evt.ports[0].postMessage({ now: performance.now(), timeOrigin: performance.timeOrigin }); + }; + </script> + + <script class="testbody" type="text/javascript"> + +function testBasic() { + ok("timeOrigin" in performance, "Performance.timeOrigin exists."); + ok(performance.timeOrigin > 0, "TimeOrigin must be greater than 0."); + next(); +} + +function testWorker() { + var now = performance.now(); + + var blob = new Blob([ document.getElementById("worker-src").textContent ], + { type: "text/javascript" }); + var w = new Worker(URL.createObjectURL(blob)); + w.onmessage = function(e) { + ok (e.data.now + e.data.timeOrigin > now + performance.timeOrigin, "Comparing worker.now and window.now"); + next(); + } +} + +function testSharedWorker() { + var now = performance.now(); + + var blob = new Blob([ document.getElementById("shared-worker-src").textContent ], + { type: "text/javascript" }); + var w = new SharedWorker(URL.createObjectURL(blob)); + w.port.onmessage = function(e) { + ok (e.data.now + e.data.timeOrigin > now + performance.timeOrigin, "Comparing worker.now and window.now"); + next(); + } +} + +var tests = [ testBasic, testWorker, testSharedWorker ]; +function next() { + if (!tests.length) { + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", reduceTimePrecisionPrevPrefValue); + SimpleTest.finish(); + return; + } + + var test = tests.shift(); + test(); +} + +SimpleTest.waitForExplicitFinish(); + +// It is a known issue that comparing time between a worker and a window +// when timer clamping is in effect may cause time to go backwards. +// Do not run this test with this preference set. For large values of +// clamping you will see failures. For small values, it is intermitant. +var reduceTimePrecisionPrevPrefValue = SpecialPowers.getBoolPref("privacy.reduceTimerPrecision"); +SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", false); + +addLoadEvent(next); + </script> + </pre> + </body> +</html> diff --git a/dom/performance/tests/test_worker_observer.html b/dom/performance/tests/test_worker_observer.html new file mode 100644 index 0000000000..7f4df855c9 --- /dev/null +++ b/dom/performance/tests/test_worker_observer.html @@ -0,0 +1,41 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE html> +<html> +<head> +<meta charset=utf-8> +<title>Test for performance observer in worker</title> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +</head> +<body> +<div id="log"></div> +<script> +const worker = new Worker("worker_performance_observer.js"); + +promise_test(t => { + let found = false; + return new Promise(resolve => { + SpecialPowers.registerConsoleListener(msg => { + if (msg.errorMessage === "Ignoring unsupported entryTypes: invalid.") { + found = true; + resolve(); + } + }); + worker.addEventListener("error", resolve); + worker.addEventListener("message", function(event) { + if (event.data.type === "complete") { + resolve(); + } + }); + }).then(() => { + SpecialPowers.postConsoleSentinel(); + assert_true(found, "got the expected console warning"); + }); +}, "Console warnings about invalid types should be logged during the tests"); + +fetch_tests_from_worker(worker); +</script> +</body> diff --git a/dom/performance/tests/test_worker_performance_entries.html b/dom/performance/tests/test_worker_performance_entries.html new file mode 100644 index 0000000000..d3f124fdb3 --- /dev/null +++ b/dom/performance/tests/test_worker_performance_entries.html @@ -0,0 +1,39 @@ +<!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +<!DOCTYPE HTML> +<html> +<head> + <title>PerformanceResouceTiming in workers</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script class="testbody" type="text/javascript"> + +SimpleTest.waitForExplicitFinish(); + +// The worker assumes it will take some amount of time to load a resource. +// With a low enough precision, the duration to load a resource may clamp +// down to zero. +var reduceTimePrecisionPrevPrefValue = SpecialPowers.getBoolPref("privacy.reduceTimerPrecision"); +SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", false); + +var worker = new Worker('test_worker_performance_entries.js'); +worker.onmessage = function(event) { + if (event.data.type == "check") { + ok(event.data.status, event.data.msg); + return; + } + + if (event.data.type == "finish") { + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", reduceTimePrecisionPrevPrefValue); + SimpleTest.finish(); + return; + } + + ok(false, "?!?"); +} + +</script> +</body> +</html> diff --git a/dom/performance/tests/test_worker_performance_entries.js b/dom/performance/tests/test_worker_performance_entries.js new file mode 100644 index 0000000000..e3d660bd85 --- /dev/null +++ b/dom/performance/tests/test_worker_performance_entries.js @@ -0,0 +1,120 @@ +function ok(a, msg) { + postMessage({ type: "check", status: !!a, msg }); +} + +function is(a, b, msg) { + ok(a === b, msg); +} + +function finish(a, msg) { + postMessage({ type: "finish" }); +} + +async function wait_for_performance_entries() { + let promise = new Promise(resolve => { + new PerformanceObserver(list => { + resolve(list.getEntries()); + }).observe({ entryTypes: ["resource"] }); + }); + entries = await promise; + return entries; +} + +async function check(resource, initiatorType, protocol) { + let entries = performance.getEntries(); + if (!entries.length) { + entries = await wait_for_performance_entries(); + } + ok(entries.length == 1, "We have an entry"); + + ok(entries[0] instanceof PerformanceEntry, "The entry is a PerformanceEntry"); + ok(entries[0].name.endsWith(resource), "The entry has been found!"); + + is(entries[0].entryType, "resource", "Correct EntryType"); + ok(entries[0].startTime > 0, "We have a startTime"); + ok(entries[0].duration > 0, "We have a duration"); + + ok( + entries[0] instanceof PerformanceResourceTiming, + "The entry is a PerformanceResourceTiming" + ); + + is(entries[0].initiatorType, initiatorType, "Correct initiatorType"); + is(entries[0].nextHopProtocol, protocol, "Correct protocol"); + + performance.clearResourceTimings(); +} + +function simple_checks() { + ok("performance" in self, "We have self.performance"); + performance.clearResourceTimings(); + next(); +} + +function fetch_request() { + fetch("test_worker_performance_entries.sjs") + .then(r => r.blob()) + .then(blob => { + check("test_worker_performance_entries.sjs", "fetch", "http/1.1"); + }) + .then(next); +} + +function xhr_request() { + let xhr = new XMLHttpRequest(); + xhr.open("GET", "test_worker_performance_entries.sjs"); + xhr.send(); + xhr.onload = () => { + check("test_worker_performance_entries.sjs", "xmlhttprequest", "http/1.1"); + next(); + }; +} + +function sync_xhr_request() { + let xhr = new XMLHttpRequest(); + xhr.open("GET", "test_worker_performance_entries.sjs", false); + xhr.send(); + check("test_worker_performance_entries.sjs", "xmlhttprequest", "http/1.1"); + next(); +} + +function import_script() { + importScripts(["empty.js"]); + check("empty.js", "other", "http/1.1"); + next(); +} + +function redirect() { + fetch("test_worker_performance_entries.sjs?redirect") + .then(r => r.text()) + .then(async text => { + is(text, "Hello world \\o/", "The redirect worked correctly"); + await check( + "test_worker_performance_entries.sjs?redirect", + "fetch", + "http/1.1" + ); + }) + .then(next); +} + +let tests = [ + simple_checks, + fetch_request, + xhr_request, + sync_xhr_request, + import_script, + redirect, +]; + +function next() { + if (!tests.length) { + finish(); + return; + } + + let test = tests.shift(); + test(); +} + +next(); diff --git a/dom/performance/tests/test_worker_performance_entries.sjs b/dom/performance/tests/test_worker_performance_entries.sjs new file mode 100644 index 0000000000..62f00c22bc --- /dev/null +++ b/dom/performance/tests/test_worker_performance_entries.sjs @@ -0,0 +1,11 @@ +function handleRequest(request, response) { + response.setHeader("Content-Type", "text/html"); + + if (request.queryString == "redirect") { + response.setStatusLine(request.httpVersion, 302, "See Other"); + response.setHeader("Location", "test_worker_performance_entries.sjs?ok"); + } else { + response.setStatusLine(request.httpVersion, 200, "OK"); + response.write("Hello world \\o/"); + } +} diff --git a/dom/performance/tests/test_worker_performance_now.html b/dom/performance/tests/test_worker_performance_now.html new file mode 100644 index 0000000000..be4f8f56ea --- /dev/null +++ b/dom/performance/tests/test_worker_performance_now.html @@ -0,0 +1,31 @@ +<!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +<!DOCTYPE HTML> +<html> +<head> + <title>Validate Interfaces Exposed to Workers</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script class="testbody" type="text/javascript"> + +SimpleTest.waitForExplicitFinish(); + +var reduceTimePrecisionPrevPrefValue = SpecialPowers.getBoolPref("privacy.reduceTimerPrecision"); +SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", false); + +var worker = new Worker('test_worker_performance_now.js'); +worker.onmessage = function(event) { + if (event.data.type == 'finish') { + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", reduceTimePrecisionPrevPrefValue); + SimpleTest.finish(); + + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } +} + +</script> +</body> +</html> diff --git a/dom/performance/tests/test_worker_performance_now.js b/dom/performance/tests/test_worker_performance_now.js new file mode 100644 index 0000000000..a22f66256e --- /dev/null +++ b/dom/performance/tests/test_worker_performance_now.js @@ -0,0 +1,68 @@ +function ok(a, msg) { + dump("OK: " + !!a + " => " + a + ": " + msg + "\n"); + postMessage({ type: "status", status: !!a, msg: a + ": " + msg }); +} + +function workerTestDone() { + postMessage({ type: "finish" }); +} + +ok(self.performance, "Performance object should exist."); +ok( + typeof self.performance.now == "function", + "Performance object should have a 'now' method." +); +var n = self.performance.now(), + d = Date.now(); +ok(n >= 0, "The value of now() should be equal to or greater than 0."); +ok( + self.performance.now() >= n, + "The value of now() should monotonically increase." +); + +// Spin on setTimeout() until performance.now() increases. Due to recent +// security developments, the hr-time working group has not yet reached +// consensus on what the recommend minimum clock resolution should be: +// https://w3c.github.io/hr-time/#clock-resolution +// Since setTimeout might return too early/late, our goal is for +// performance.now() to increase before a 2 ms deadline rather than specific +// number of setTimeout(N) invocations. +// See bug 749894 (intermittent failures of this test) +setTimeout(checkAfterTimeout, 1); + +var checks = 0; + +function checkAfterTimeout() { + checks++; + var d2 = Date.now(); + var n2 = self.performance.now(); + + // Spin on setTimeout() until performance.now() increases. Abort the test + // if it runs for more than 2 ms or 50 timeouts. + let elapsedTime = d2 - d; + let elapsedPerf = n2 - n; + if (elapsedPerf == 0 && elapsedTime < 2 && checks < 50) { + setTimeout(checkAfterTimeout, 1); + return; + } + + // Our implementation provides 1 ms resolution (bug 1451790), but we + // can't assert that elapsedPerf >= 1 ms because this worker test runs with + // "privacy.reduceTimerPrecision" == false so performance.now() is not + // limited to 1 ms resolution. + ok( + elapsedPerf > 0, + `Loose - the value of now() should increase after 2ms. ` + + `delta now(): ${elapsedPerf} ms` + ); + + // If we need more than 1 iteration, then either performance.now() resolution + // is shorter than 1 ms or setTimeout() is returning too early. + ok( + checks == 1, + `Strict - the value of now() should increase after one setTimeout. ` + + `iters: ${checks}, dt: ${elapsedTime}, now(): ${n2}` + ); + + workerTestDone(); +} diff --git a/dom/performance/tests/test_worker_user_timing.html b/dom/performance/tests/test_worker_user_timing.html new file mode 100644 index 0000000000..ebeac24e4f --- /dev/null +++ b/dom/performance/tests/test_worker_user_timing.html @@ -0,0 +1,30 @@ +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<!DOCTYPE HTML> +<html> + <head> + <title>Test for worker performance timing API</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8"> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + </head> + <body> + <script class="testbody" type="text/javascript"> + +var worker = new Worker('worker_performance_user_timing.js'); +worker.onmessage = function(event) { + if (event.data.type == 'finish') { + SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", reduceTimePrecisionPrevPrefValue); + SimpleTest.finish(); + } else if (event.data.type == 'status') { + ok(event.data.status, event.data.msg); + } +} + +var reduceTimePrecisionPrevPrefValue = SpecialPowers.getBoolPref("privacy.reduceTimerPrecision"); +SpecialPowers.setBoolPref("privacy.reduceTimerPrecision", false); +SimpleTest.waitForExplicitFinish(); + </script> + </body> +</html> diff --git a/dom/performance/tests/worker_performance_observer.js b/dom/performance/tests/worker_performance_observer.js new file mode 100644 index 0000000000..3282c9d157 --- /dev/null +++ b/dom/performance/tests/worker_performance_observer.js @@ -0,0 +1,4 @@ +importScripts(["/resources/testharness.js"]); +importScripts(["test_performance_observer.js"]); + +done(); diff --git a/dom/performance/tests/worker_performance_user_timing.js b/dom/performance/tests/worker_performance_user_timing.js new file mode 100644 index 0000000000..257040f09f --- /dev/null +++ b/dom/performance/tests/worker_performance_user_timing.js @@ -0,0 +1,32 @@ +function ok(a, msg) { + dump("OK: " + !!a + " => " + a + " " + msg + "\n"); + postMessage({ type: "status", status: !!a, msg: a + ": " + msg }); +} + +function is(a, b, msg) { + dump("IS: " + (a === b) + " => " + a + " | " + b + " " + msg + "\n"); + postMessage({ + type: "status", + status: a === b, + msg: a + " === " + b + ": " + msg, + }); +} + +function isnot(a, b, msg) { + dump("ISNOT: " + (a === b) + " => " + a + " | " + b + " " + msg + "\n"); + postMessage({ + type: "status", + status: a != b, + msg: a + " != " + b + ": " + msg, + }); +} + +importScripts(["test_performance_user_timing.js"]); + +for (var i = 0; i < steps.length; ++i) { + performance.clearMarks(); + performance.clearMeasures(); + steps[i](); +} + +postMessage({ type: "finish" }); |
