/* -*- 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 "nsDOMWindowUtils.h" #include "mozilla/layers/CompositorBridgeChild.h" #include "mozilla/layers/LayerTransactionChild.h" #include "nsPresContext.h" #include "nsError.h" #include "nsIDOMEvent.h" #include "nsQueryContentEventResult.h" #include "nsGlobalWindow.h" #include "nsIDocument.h" #include "nsFocusManager.h" #include "nsFrameManager.h" #include "nsRefreshDriver.h" #include "mozilla/dom/BindingDeclarations.h" #include "mozilla/dom/BlobBinding.h" #include "mozilla/dom/Touch.h" #include "mozilla/PendingAnimationTracker.h" #include "nsIObjectLoadingContent.h" #include "nsFrame.h" #include "mozilla/layers/ShadowLayers.h" #include "mozilla/layers/APZCCallbackHelper.h" #include "ClientLayerManager.h" #include "nsQueryObject.h" #include "CubebUtils.h" #include "nsIScrollableFrame.h" #include "nsContentUtils.h" #include "nsIFrame.h" #include "nsIWidget.h" #include "nsCharsetSource.h" #include "nsJSEnvironment.h" #include "nsJSUtils.h" #include "mozilla/ChaosMode.h" #include "mozilla/EventStateManager.h" #include "mozilla/MiscEvents.h" #include "mozilla/MouseEvents.h" #include "mozilla/TextEvents.h" #include "mozilla/TextEventDispatcher.h" #include "mozilla/TouchEvents.h" #include "nsViewManager.h" #include "nsLayoutUtils.h" #include "nsComputedDOMStyle.h" #include "nsIPresShell.h" #include "nsCSSProps.h" #include "nsTArrayHelpers.h" #include "nsIDocShell.h" #include "nsIContentViewer.h" #include "mozilla/StyleAnimationValue.h" #include "mozilla/dom/File.h" #include "mozilla/dom/FileBinding.h" #include "mozilla/dom/DOMRect.h" #include #if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK) #include #include #endif #include "Layers.h" #include "gfxPrefs.h" #include "mozilla/dom/AudioDeviceInfo.h" #include "mozilla/dom/Element.h" #include "mozilla/dom/TabChild.h" #include "mozilla/dom/IDBFactoryBinding.h" #include "mozilla/dom/IDBMutableFileBinding.h" #include "mozilla/dom/IDBMutableFile.h" #include "mozilla/dom/IndexedDatabaseManager.h" #include "mozilla/dom/PermissionMessageUtils.h" #include "mozilla/dom/Text.h" #include "mozilla/dom/quota/PersistenceType.h" #include "mozilla/dom/quota/QuotaManager.h" #include "mozilla/dom/ContentChild.h" #include "mozilla/layers/FrameUniformityData.h" #include "mozilla/layers/ShadowLayers.h" #include "nsPrintfCString.h" #include "nsViewportInfo.h" #include "nsIFormControl.h" #include "nsIScriptError.h" //#include "nsWidgetsCID.h" #include "FrameLayerBuilder.h" #include "nsDisplayList.h" #include "nsROCSSPrimitiveValue.h" #include "nsIBaseWindow.h" #include "nsIDocShellTreeOwner.h" #include "nsIInterfaceRequestorUtils.h" #include "GeckoProfiler.h" #include "mozilla/Preferences.h" #include "nsIContentIterator.h" #include "nsIStyleSheetService.h" #include "nsContentPermissionHelper.h" #include "nsCSSPseudoElements.h" // for CSSPseudoElementType #include "nsNetUtil.h" #include "nsDocument.h" #include "HTMLImageElement.h" #include "HTMLCanvasElement.h" #include "mozilla/css/ImageLoader.h" #include "mozilla/layers/IAPZCTreeManager.h" // for layers::ZoomToRectBehavior #include "mozilla/dom/Promise.h" #include "mozilla/StyleSheetInlines.h" #include "mozilla/gfx/GPUProcessManager.h" #include "mozilla/dom/TimeoutManager.h" #include "mozilla/PreloadedStyleSheet.h" #include "mozilla/layers/WebRenderBridgeChild.h" #include "mozilla/layers/WebRenderLayerManager.h" #ifdef XP_WIN #undef GetClassName #endif using namespace mozilla; using namespace mozilla::dom; using namespace mozilla::ipc; using namespace mozilla::layers; using namespace mozilla::widget; using namespace mozilla::gfx; class gfxContext; class OldWindowSize : public LinkedListElement { public: static void Set(nsIWeakReference* aWindowRef, const nsSize& aSize) { OldWindowSize* item = GetItem(aWindowRef); if (item) { item->mSize = aSize; } else { item = new OldWindowSize(aWindowRef, aSize); sList.insertBack(item); } } static nsSize GetAndRemove(nsIWeakReference* aWindowRef) { nsSize result; if (OldWindowSize* item = GetItem(aWindowRef)) { result = item->mSize; delete item; } return result; } private: explicit OldWindowSize(nsIWeakReference* aWindowRef, const nsSize& aSize) : mWindowRef(aWindowRef), mSize(aSize) { } ~OldWindowSize() = default;; static OldWindowSize* GetItem(nsIWeakReference* aWindowRef) { OldWindowSize* item = sList.getFirst(); while (item && item->mWindowRef != aWindowRef) { item = item->getNext(); } return item; } static LinkedList sList; nsWeakPtr mWindowRef; nsSize mSize; }; namespace { class NativeInputRunnable final : public PrioritizableRunnable { explicit NativeInputRunnable(already_AddRefed&& aEvent); ~NativeInputRunnable() {} public: static already_AddRefed Create(already_AddRefed&& aEvent); }; NativeInputRunnable::NativeInputRunnable(already_AddRefed&& aEvent) : PrioritizableRunnable(Move(aEvent), nsIRunnablePriority::PRIORITY_INPUT) { } /* static */ already_AddRefed NativeInputRunnable::Create(already_AddRefed&& aEvent) { MOZ_ASSERT(NS_IsMainThread()); nsCOMPtr event(new NativeInputRunnable(Move(aEvent))); return event.forget(); } } // unnamed namespace LinkedList OldWindowSize::sList; NS_INTERFACE_MAP_BEGIN(nsDOMWindowUtils) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMWindowUtils) NS_INTERFACE_MAP_ENTRY(nsIDOMWindowUtils) NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) NS_INTERFACE_MAP_END NS_IMPL_ADDREF(nsDOMWindowUtils) NS_IMPL_RELEASE(nsDOMWindowUtils) nsDOMWindowUtils::nsDOMWindowUtils(nsGlobalWindowOuter *aWindow) { nsCOMPtr supports = do_QueryObject(aWindow); mWindow = do_GetWeakReference(supports); } nsDOMWindowUtils::~nsDOMWindowUtils() { OldWindowSize::GetAndRemove(mWindow); } nsIPresShell* nsDOMWindowUtils::GetPresShell() { nsCOMPtr window = do_QueryReferent(mWindow); if (!window) return nullptr; nsIDocShell *docShell = window->GetDocShell(); if (!docShell) return nullptr; return docShell->GetPresShell(); } nsPresContext* nsDOMWindowUtils::GetPresContext() { nsCOMPtr window = do_QueryReferent(mWindow); if (!window) return nullptr; nsIDocShell *docShell = window->GetDocShell(); if (!docShell) return nullptr; RefPtr presContext; docShell->GetPresContext(getter_AddRefs(presContext)); return presContext; } nsIDocument* nsDOMWindowUtils::GetDocument() { nsCOMPtr window = do_QueryReferent(mWindow); if (!window) { return nullptr; } return window->GetExtantDoc(); } LayerTransactionChild* nsDOMWindowUtils::GetLayerTransaction() { nsIWidget* widget = GetWidget(); if (!widget) return nullptr; LayerManager* manager = widget->GetLayerManager(); if (!manager) return nullptr; ShadowLayerForwarder* forwarder = manager->AsShadowForwarder(); return forwarder && forwarder->HasShadowManager() ? forwarder->GetShadowManager() : nullptr; } WebRenderBridgeChild* nsDOMWindowUtils::GetWebRenderBridge() { if (nsIWidget* widget = GetWidget()) { if (LayerManager* lm = widget->GetLayerManager()) { if (WebRenderLayerManager* wrlm = lm->AsWebRenderLayerManager()) { return wrlm->WrBridge(); } } } return nullptr; } NS_IMETHODIMP nsDOMWindowUtils::GetImageAnimationMode(uint16_t *aMode) { NS_ENSURE_ARG_POINTER(aMode); *aMode = 0; nsPresContext* presContext = GetPresContext(); if (presContext) { *aMode = presContext->ImageAnimationMode(); return NS_OK; } return NS_ERROR_NOT_AVAILABLE; } NS_IMETHODIMP nsDOMWindowUtils::SetImageAnimationMode(uint16_t aMode) { nsPresContext* presContext = GetPresContext(); if (presContext) { presContext->SetImageAnimationMode(aMode); return NS_OK; } return NS_ERROR_NOT_AVAILABLE; } NS_IMETHODIMP nsDOMWindowUtils::GetDocCharsetIsForced(bool *aIsForced) { *aIsForced = false; nsIDocument* doc = GetDocument(); *aIsForced = doc && doc->GetDocumentCharacterSetSource() >= kCharsetFromParentForced; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetPhysicalMillimeterInCSSPixels(float* aPhysicalMillimeter) { nsPresContext* presContext = GetPresContext(); if (!presContext) { return NS_ERROR_NOT_AVAILABLE; } *aPhysicalMillimeter = nsPresContext::AppUnitsToFloatCSSPixels( presContext->PhysicalMillimetersToAppUnits(1)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetDocumentMetadata(const nsAString& aName, nsAString& aValue) { nsIDocument* doc = GetDocument(); if (doc) { RefPtr name = NS_Atomize(aName); doc->GetHeaderData(name, aValue); return NS_OK; } aValue.Truncate(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::Redraw(uint32_t aCount, uint32_t *aDurationOut) { if (aCount == 0) aCount = 1; if (nsIPresShell* presShell = GetPresShell()) { nsIFrame *rootFrame = presShell->GetRootFrame(); if (rootFrame) { PRIntervalTime iStart = PR_IntervalNow(); for (uint32_t i = 0; i < aCount; i++) rootFrame->InvalidateFrame(); #if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK) if (!gfxPlatform::IsHeadless()) { XSync(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), False); } #endif *aDurationOut = PR_IntervalToMilliseconds(PR_IntervalNow() - iStart); return NS_OK; } } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDOMWindowUtils::UpdateLayerTree() { if (nsIPresShell* presShell = GetPresShell()) { // Don't flush throttled animations since it might fire MozAfterPaint event // (in WebRender it constantly does), thus the reftest harness can't take // any snapshot until the throttled animations finished. presShell->FlushPendingNotifications( ChangesToFlush(FlushType::Display, false /* flush animations */)); RefPtr vm = presShell->GetViewManager(); nsView* view = vm->GetRootView(); if (view) { presShell->Paint(view, view->GetBounds(), nsIPresShell::PAINT_LAYERS | nsIPresShell::PAINT_SYNC_DECODE_IMAGES); presShell->GetLayerManager()->WaitOnTransactionProcessed(); } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetContentViewerSize(uint32_t *aDisplayWidth, uint32_t *aDisplayHeight) { nsIPresShell* presShell = GetPresShell(); LayoutDeviceIntSize displaySize; if (!presShell || !nsLayoutUtils::GetContentViewerSize(presShell->GetPresContext(), displaySize)) { return NS_ERROR_FAILURE; } *aDisplayWidth = displaySize.width; *aDisplayHeight = displaySize.height; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetViewportInfo(uint32_t aDisplayWidth, uint32_t aDisplayHeight, double *aDefaultZoom, bool *aAllowZoom, double *aMinZoom, double *aMaxZoom, uint32_t *aWidth, uint32_t *aHeight, bool *aAutoSize) { nsIDocument* doc = GetDocument(); NS_ENSURE_STATE(doc); nsViewportInfo info = doc->GetViewportInfo(ScreenIntSize(aDisplayWidth, aDisplayHeight)); *aDefaultZoom = info.GetDefaultZoom().scale; *aAllowZoom = info.IsZoomAllowed(); *aMinZoom = info.GetMinZoom().scale; *aMaxZoom = info.GetMaxZoom().scale; CSSIntSize size = gfx::RoundedToInt(info.GetSize()); *aWidth = size.width; *aHeight = size.height; *aAutoSize = info.IsAutoSizeEnabled(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetDisplayPortForElement(float aXPx, float aYPx, float aWidthPx, float aHeightPx, nsIDOMElement* aElement, uint32_t aPriority) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } if (!aElement) { return NS_ERROR_INVALID_ARG; } nsCOMPtr content = do_QueryInterface(aElement); if (!content) { return NS_ERROR_INVALID_ARG; } if (content->GetUncomposedDoc() != presShell->GetDocument()) { return NS_ERROR_INVALID_ARG; } DisplayPortPropertyData* currentData = static_cast(content->GetProperty(nsGkAtoms::DisplayPort)); if (currentData && currentData->mPriority > aPriority) { return NS_OK; } nsRect displayport(nsPresContext::CSSPixelsToAppUnits(aXPx), nsPresContext::CSSPixelsToAppUnits(aYPx), nsPresContext::CSSPixelsToAppUnits(aWidthPx), nsPresContext::CSSPixelsToAppUnits(aHeightPx)); content->SetProperty(nsGkAtoms::DisplayPort, new DisplayPortPropertyData(displayport, aPriority), nsINode::DeleteProperty); if (gfxPrefs::LayoutUseContainersForRootFrames()) { nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame(); if (rootScrollFrame && content == rootScrollFrame->GetContent() && nsLayoutUtils::UsesAsyncScrolling(rootScrollFrame)) { // We are setting a root displayport for a document. // The pres shell needs a special flag set. presShell->SetIgnoreViewportScrolling(true); } } nsLayoutUtils::InvalidateForDisplayPortChange(content, !!currentData, currentData ? currentData->mRect : nsRect(), displayport); nsIFrame* rootFrame = presShell->GetRootFrame(); if (rootFrame) { rootFrame->SchedulePaint(); // If we are hiding something that is a display root then send empty paint // transaction in order to release retained layers because it won't get // any more paint requests when it is hidden. if (displayport.IsEmpty() && rootFrame == nsLayoutUtils::GetDisplayRootFrame(rootFrame)) { nsCOMPtr widget = GetWidget(); if (widget) { LayerManager* manager = widget->GetLayerManager(); manager->BeginTransaction(); using PaintFrameFlags = nsLayoutUtils::PaintFrameFlags; nsLayoutUtils::PaintFrame(nullptr, rootFrame, nsRegion(), NS_RGB(255, 255, 255), nsDisplayListBuilderMode::PAINTING, PaintFrameFlags::PAINT_WIDGET_LAYERS | PaintFrameFlags::PAINT_EXISTING_TRANSACTION); } } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetDisplayPortMarginsForElement(float aLeftMargin, float aTopMargin, float aRightMargin, float aBottomMargin, nsIDOMElement* aElement, uint32_t aPriority) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } if (!aElement) { return NS_ERROR_INVALID_ARG; } nsCOMPtr content = do_QueryInterface(aElement); if (!content) { return NS_ERROR_INVALID_ARG; } if (content->GetUncomposedDoc() != presShell->GetDocument()) { return NS_ERROR_INVALID_ARG; } // Note order change of arguments between our function signature and // ScreenMargin constructor. ScreenMargin displayportMargins(aTopMargin, aRightMargin, aBottomMargin, aLeftMargin); nsLayoutUtils::SetDisplayPortMargins(content, presShell, displayportMargins, aPriority); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetDisplayPortBaseForElement(int32_t aX, int32_t aY, int32_t aWidth, int32_t aHeight, nsIDOMElement* aElement) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } if (!aElement) { return NS_ERROR_INVALID_ARG; } nsCOMPtr content = do_QueryInterface(aElement); if (!content) { return NS_ERROR_INVALID_ARG; } if (content->GetUncomposedDoc() != presShell->GetDocument()) { return NS_ERROR_INVALID_ARG; } nsLayoutUtils::SetDisplayPortBase(content, nsRect(aX, aY, aWidth, aHeight)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetResolution(float aResolution) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } presShell->SetResolution(aResolution); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetResolutionAndScaleTo(float aResolution) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } presShell->SetResolutionAndScaleTo(aResolution); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetRestoreResolution(float aResolution, uint32_t aDisplayWidth, uint32_t aDisplayHeight) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } presShell->SetRestoreResolution(aResolution, LayoutDeviceIntSize(aDisplayWidth, aDisplayHeight)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetResolution(float* aResolution) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } *aResolution = presShell->GetResolution(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIsResolutionSet(bool* aIsResolutionSet) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } *aIsResolutionSet = presShell->IsResolutionSet(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetIsFirstPaint(bool aIsFirstPaint) { nsIPresShell* presShell = GetPresShell(); if (presShell) { presShell->SetIsFirstPaint(aIsFirstPaint); return NS_OK; } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDOMWindowUtils::GetIsFirstPaint(bool *aIsFirstPaint) { nsIPresShell* presShell = GetPresShell(); if (presShell) { *aIsFirstPaint = presShell->GetIsFirstPaint(); return NS_OK; } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDOMWindowUtils::GetPresShellId(uint32_t *aPresShellId) { nsIPresShell* presShell = GetPresShell(); if (presShell) { *aPresShellId = presShell->GetPresShellId(); return NS_OK; } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDOMWindowUtils::SendMouseEvent(const nsAString& aType, float aX, float aY, int32_t aButton, int32_t aClickCount, int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, unsigned short aInputSourceArg, bool aIsDOMEventSynthesized, bool aIsWidgetEventSynthesized, int32_t aButtons, uint32_t aIdentifier, uint8_t aOptionalArgCount, bool *aPreventDefault) { return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers, aIgnoreRootScrollFrame, aPressure, aInputSourceArg, aOptionalArgCount >= 7 ? aIdentifier : DEFAULT_MOUSE_POINTER_ID, false, aPreventDefault, aOptionalArgCount >= 4 ? aIsDOMEventSynthesized : true, aOptionalArgCount >= 5 ? aIsWidgetEventSynthesized : false, aOptionalArgCount >= 6 ? aButtons : MOUSE_BUTTONS_NOT_SPECIFIED); } NS_IMETHODIMP nsDOMWindowUtils::SendMouseEventToWindow(const nsAString& aType, float aX, float aY, int32_t aButton, int32_t aClickCount, int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, unsigned short aInputSourceArg, bool aIsDOMEventSynthesized, bool aIsWidgetEventSynthesized, int32_t aButtons, uint32_t aIdentifier, uint8_t aOptionalArgCount) { AUTO_PROFILER_LABEL("nsDOMWindowUtils::SendMouseEventToWindow", EVENTS); return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers, aIgnoreRootScrollFrame, aPressure, aInputSourceArg, aOptionalArgCount >= 7 ? aIdentifier : DEFAULT_MOUSE_POINTER_ID, true, nullptr, aOptionalArgCount >= 4 ? aIsDOMEventSynthesized : true, aOptionalArgCount >= 5 ? aIsWidgetEventSynthesized : false, aOptionalArgCount >= 6 ? aButtons : MOUSE_BUTTONS_NOT_SPECIFIED); } NS_IMETHODIMP nsDOMWindowUtils::SendMouseEventCommon(const nsAString& aType, float aX, float aY, int32_t aButton, int32_t aClickCount, int32_t aModifiers, bool aIgnoreRootScrollFrame, float aPressure, unsigned short aInputSourceArg, uint32_t aPointerId, bool aToWindow, bool *aPreventDefault, bool aIsDOMEventSynthesized, bool aIsWidgetEventSynthesized, int32_t aButtons) { nsCOMPtr presShell = GetPresShell(); return nsContentUtils::SendMouseEvent(presShell, aType, aX, aY, aButton, aButtons, aClickCount, aModifiers, aIgnoreRootScrollFrame, aPressure, aInputSourceArg, aPointerId, aToWindow, aPreventDefault, aIsDOMEventSynthesized, aIsWidgetEventSynthesized); } NS_IMETHODIMP nsDOMWindowUtils::SendWheelEvent(float aX, float aY, double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aDeltaMode, int32_t aModifiers, int32_t aLineOrPageDeltaX, int32_t aLineOrPageDeltaY, uint32_t aOptions) { // get the widget to send the event to nsPoint offset; nsCOMPtr widget = GetWidget(&offset); if (!widget) { return NS_ERROR_NULL_POINTER; } WidgetWheelEvent wheelEvent(true, eWheel, widget); wheelEvent.mModifiers = nsContentUtils::GetWidgetModifiers(aModifiers); wheelEvent.mDeltaX = aDeltaX; wheelEvent.mDeltaY = aDeltaY; wheelEvent.mDeltaZ = aDeltaZ; wheelEvent.mDeltaMode = aDeltaMode; wheelEvent.mIsMomentum = (aOptions & WHEEL_EVENT_CAUSED_BY_MOMENTUM) != 0; wheelEvent.mIsNoLineOrPageDelta = (aOptions & WHEEL_EVENT_CAUSED_BY_NO_LINE_OR_PAGE_DELTA_DEVICE) != 0; wheelEvent.mCustomizedByUserPrefs = (aOptions & WHEEL_EVENT_CUSTOMIZED_BY_USER_PREFS) != 0; wheelEvent.mLineOrPageDeltaX = aLineOrPageDeltaX; wheelEvent.mLineOrPageDeltaY = aLineOrPageDeltaY; wheelEvent.mTime = PR_Now() / 1000; nsPresContext* presContext = GetPresContext(); NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE); wheelEvent.mRefPoint = nsContentUtils::ToWidgetPoint(CSSPoint(aX, aY), offset, presContext); widget->DispatchInputEvent(&wheelEvent); if (widget->AsyncPanZoomEnabled()) { // Computing overflow deltas is not compatible with APZ, so if APZ is // enabled, we skip testing it. return NS_OK; } bool failedX = false; if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_ZERO) && wheelEvent.mOverflowDeltaX != 0) { failedX = true; } if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_POSITIVE) && wheelEvent.mOverflowDeltaX <= 0) { failedX = true; } if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_NEGATIVE) && wheelEvent.mOverflowDeltaX >= 0) { failedX = true; } bool failedY = false; if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_ZERO) && wheelEvent.mOverflowDeltaY != 0) { failedY = true; } if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_POSITIVE) && wheelEvent.mOverflowDeltaY <= 0) { failedY = true; } if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_NEGATIVE) && wheelEvent.mOverflowDeltaY >= 0) { failedY = true; } #ifdef DEBUG if (failedX) { nsPrintfCString debugMsg("SendWheelEvent(): unexpected mOverflowDeltaX: %f", wheelEvent.mOverflowDeltaX); NS_WARNING(debugMsg.get()); } if (failedY) { nsPrintfCString debugMsg("SendWheelEvent(): unexpected mOverflowDeltaY: %f", wheelEvent.mOverflowDeltaY); NS_WARNING(debugMsg.get()); } #endif return (!failedX && !failedY) ? NS_OK : NS_ERROR_FAILURE; } NS_IMETHODIMP nsDOMWindowUtils::SendTouchEvent(const nsAString& aType, uint32_t *aIdentifiers, int32_t *aXs, int32_t *aYs, uint32_t *aRxs, uint32_t *aRys, float *aRotationAngles, float *aForces, uint32_t aCount, int32_t aModifiers, bool aIgnoreRootScrollFrame, bool *aPreventDefault) { return SendTouchEventCommon(aType, aIdentifiers, aXs, aYs, aRxs, aRys, aRotationAngles, aForces, aCount, aModifiers, aIgnoreRootScrollFrame, false, aPreventDefault); } NS_IMETHODIMP nsDOMWindowUtils::SendTouchEventToWindow(const nsAString& aType, uint32_t* aIdentifiers, int32_t* aXs, int32_t* aYs, uint32_t* aRxs, uint32_t* aRys, float* aRotationAngles, float* aForces, uint32_t aCount, int32_t aModifiers, bool aIgnoreRootScrollFrame, bool* aPreventDefault) { return SendTouchEventCommon(aType, aIdentifiers, aXs, aYs, aRxs, aRys, aRotationAngles, aForces, aCount, aModifiers, aIgnoreRootScrollFrame, true, aPreventDefault); } NS_IMETHODIMP nsDOMWindowUtils::SendTouchEventCommon(const nsAString& aType, uint32_t* aIdentifiers, int32_t* aXs, int32_t* aYs, uint32_t* aRxs, uint32_t* aRys, float* aRotationAngles, float* aForces, uint32_t aCount, int32_t aModifiers, bool aIgnoreRootScrollFrame, bool aToWindow, bool* aPreventDefault) { // get the widget to send the event to nsPoint offset; nsCOMPtr widget = GetWidget(&offset); if (!widget) { return NS_ERROR_NULL_POINTER; } EventMessage msg; if (aType.EqualsLiteral("touchstart")) { msg = eTouchStart; } else if (aType.EqualsLiteral("touchmove")) { msg = eTouchMove; } else if (aType.EqualsLiteral("touchend")) { msg = eTouchEnd; } else if (aType.EqualsLiteral("touchcancel")) { msg = eTouchCancel; } else { return NS_ERROR_UNEXPECTED; } WidgetTouchEvent event(true, msg, widget); event.mModifiers = nsContentUtils::GetWidgetModifiers(aModifiers); event.mTime = PR_Now(); nsPresContext* presContext = GetPresContext(); if (!presContext) { return NS_ERROR_FAILURE; } event.mTouches.SetCapacity(aCount); for (uint32_t i = 0; i < aCount; ++i) { LayoutDeviceIntPoint pt = nsContentUtils::ToWidgetPoint(CSSPoint(aXs[i], aYs[i]), offset, presContext); LayoutDeviceIntPoint radius = LayoutDeviceIntPoint::FromAppUnitsRounded( CSSPoint::ToAppUnits(CSSPoint(aRxs[i], aRys[i])), presContext->AppUnitsPerDevPixel()); RefPtr t = new Touch(aIdentifiers[i], pt, radius, aRotationAngles[i], aForces[i]); event.mTouches.AppendElement(t); } nsEventStatus status; if (aToWindow) { nsCOMPtr presShell; nsView* view = nsContentUtils::GetViewToDispatchEvent(presContext, getter_AddRefs(presShell)); if (!presShell || !view) { return NS_ERROR_FAILURE; } status = nsEventStatus_eIgnore; *aPreventDefault = (status == nsEventStatus_eConsumeNoDefault); return presShell->HandleEvent(view->GetFrame(), &event, false, &status); } nsresult rv = widget->DispatchEvent(&event, status); *aPreventDefault = (status == nsEventStatus_eConsumeNoDefault); return rv; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeKeyEvent(int32_t aNativeKeyboardLayout, int32_t aNativeKeyCode, int32_t aModifiers, const nsAString& aCharacters, const nsAString& aUnmodifiedCharacters, nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; NS_DispatchToMainThread(NativeInputRunnable::Create( NewRunnableMethod("nsIWidget::SynthesizeNativeKeyEvent", widget, &nsIWidget::SynthesizeNativeKeyEvent, aNativeKeyboardLayout, aNativeKeyCode, aModifiers, aCharacters, aUnmodifiedCharacters, aObserver))); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeMouseEvent(int32_t aScreenX, int32_t aScreenY, int32_t aNativeMessage, int32_t aModifierFlags, nsIDOMElement* aElement, nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr widget = GetWidgetForElement(aElement); if (!widget) return NS_ERROR_FAILURE; NS_DispatchToMainThread(NativeInputRunnable::Create( NewRunnableMethod( "nsIWidget::SynthesizeNativeMouseEvent", widget, &nsIWidget::SynthesizeNativeMouseEvent, LayoutDeviceIntPoint(aScreenX, aScreenY), aNativeMessage, aModifierFlags, aObserver))); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeMouseMove(int32_t aScreenX, int32_t aScreenY, nsIDOMElement* aElement, nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr widget = GetWidgetForElement(aElement); if (!widget) return NS_ERROR_FAILURE; NS_DispatchToMainThread(NativeInputRunnable::Create( NewRunnableMethod( "nsIWidget::SynthesizeNativeMouseMove", widget, &nsIWidget::SynthesizeNativeMouseMove, LayoutDeviceIntPoint(aScreenX, aScreenY), aObserver))); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeMouseScrollEvent(int32_t aScreenX, int32_t aScreenY, uint32_t aNativeMessage, double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aModifierFlags, uint32_t aAdditionalFlags, nsIDOMElement* aElement, nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr widget = GetWidgetForElement(aElement); if (!widget) { return NS_ERROR_FAILURE; } NS_DispatchToMainThread(NativeInputRunnable::Create( NewRunnableMethod( "nsIWidget::SynthesizeNativeMouseScrollEvent", widget, &nsIWidget::SynthesizeNativeMouseScrollEvent, LayoutDeviceIntPoint(aScreenX, aScreenY), aNativeMessage, aDeltaX, aDeltaY, aDeltaZ, aModifierFlags, aAdditionalFlags, aObserver))); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeTouchPoint(uint32_t aPointerId, uint32_t aTouchState, int32_t aScreenX, int32_t aScreenY, double aPressure, uint32_t aOrientation, nsIObserver* aObserver) { nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } if (aPressure < 0 || aPressure > 1 || aOrientation > 359) { return NS_ERROR_INVALID_ARG; } NS_DispatchToMainThread(NativeInputRunnable::Create( NewRunnableMethod("nsIWidget::SynthesizeNativeTouchPoint", widget, &nsIWidget::SynthesizeNativeTouchPoint, aPointerId, (nsIWidget::TouchPointerState)aTouchState, LayoutDeviceIntPoint(aScreenX, aScreenY), aPressure, aOrientation, aObserver))); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeTouchTap(int32_t aScreenX, int32_t aScreenY, bool aLongTap, nsIObserver* aObserver) { nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } NS_DispatchToMainThread(NativeInputRunnable::Create( NewRunnableMethod( "nsIWidget::SynthesizeNativeTouchTap", widget, &nsIWidget::SynthesizeNativeTouchTap, LayoutDeviceIntPoint(aScreenX, aScreenY), aLongTap, aObserver))); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SuppressAnimation(bool aSuppress) { nsIWidget* widget = GetWidget(); if (widget) { widget->SuppressAnimation(aSuppress); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ClearNativeTouchSequence(nsIObserver* aObserver) { nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } NS_DispatchToMainThread(NativeInputRunnable::Create( NewRunnableMethod("nsIWidget::ClearNativeTouchSequence", widget, &nsIWidget::ClearNativeTouchSequence, aObserver))); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ActivateNativeMenuItemAt(const nsAString& indexString) { // get the widget to send the event to nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; return widget->ActivateNativeMenuItemAt(indexString); } NS_IMETHODIMP nsDOMWindowUtils::ForceUpdateNativeMenuAt(const nsAString& indexString) { // get the widget to send the event to nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; return widget->ForceUpdateNativeMenuAt(indexString); } NS_IMETHODIMP nsDOMWindowUtils::GetSelectionAsPlaintext(nsAString& aResult) { // Get the widget to send the event to. nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } return widget->GetSelectionAsPlaintext(aResult); } nsIWidget* nsDOMWindowUtils::GetWidget(nsPoint* aOffset) { nsCOMPtr window = do_QueryReferent(mWindow); if (window) { nsIDocShell *docShell = window->GetDocShell(); if (docShell) { nsCOMPtr presShell = docShell->GetPresShell(); return nsContentUtils::GetWidget(presShell, aOffset); } } return nullptr; } nsIWidget* nsDOMWindowUtils::GetWidgetForElement(nsIDOMElement* aElement) { if (!aElement) return GetWidget(); nsCOMPtr content = do_QueryInterface(aElement); nsIDocument* doc = content->GetUncomposedDoc(); nsIPresShell* presShell = doc ? doc->GetShell() : nullptr; if (presShell) { nsIFrame* frame = content->GetPrimaryFrame(); if (!frame) { frame = presShell->GetRootFrame(); } if (frame) return frame->GetNearestWidget(); } return nullptr; } NS_IMETHODIMP nsDOMWindowUtils::GarbageCollect(nsICycleCollectorListener *aListener) { AUTO_PROFILER_LABEL("nsDOMWindowUtils::GarbageCollect", GC); nsJSContext::GarbageCollectNow(JS::gcreason::DOM_UTILS); nsJSContext::CycleCollectNow(aListener); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::CycleCollect(nsICycleCollectorListener *aListener) { nsJSContext::CycleCollectNow(aListener); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::RunNextCollectorTimer() { nsJSContext::RunNextCollectorTimer(JS::gcreason::DOM_WINDOW_UTILS); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendSimpleGestureEvent(const nsAString& aType, float aX, float aY, uint32_t aDirection, double aDelta, int32_t aModifiers, uint32_t aClickCount) { // get the widget to send the event to nsPoint offset; nsCOMPtr widget = GetWidget(&offset); if (!widget) return NS_ERROR_FAILURE; EventMessage msg; if (aType.EqualsLiteral("MozSwipeGestureMayStart")) { msg = eSwipeGestureMayStart; } else if (aType.EqualsLiteral("MozSwipeGestureStart")) { msg = eSwipeGestureStart; } else if (aType.EqualsLiteral("MozSwipeGestureUpdate")) { msg = eSwipeGestureUpdate; } else if (aType.EqualsLiteral("MozSwipeGestureEnd")) { msg = eSwipeGestureEnd; } else if (aType.EqualsLiteral("MozSwipeGesture")) { msg = eSwipeGesture; } else if (aType.EqualsLiteral("MozMagnifyGestureStart")) { msg = eMagnifyGestureStart; } else if (aType.EqualsLiteral("MozMagnifyGestureUpdate")) { msg = eMagnifyGestureUpdate; } else if (aType.EqualsLiteral("MozMagnifyGesture")) { msg = eMagnifyGesture; } else if (aType.EqualsLiteral("MozRotateGestureStart")) { msg = eRotateGestureStart; } else if (aType.EqualsLiteral("MozRotateGestureUpdate")) { msg = eRotateGestureUpdate; } else if (aType.EqualsLiteral("MozRotateGesture")) { msg = eRotateGesture; } else if (aType.EqualsLiteral("MozTapGesture")) { msg = eTapGesture; } else if (aType.EqualsLiteral("MozPressTapGesture")) { msg = ePressTapGesture; } else if (aType.EqualsLiteral("MozEdgeUIStarted")) { msg = eEdgeUIStarted; } else if (aType.EqualsLiteral("MozEdgeUICanceled")) { msg = eEdgeUICanceled; } else if (aType.EqualsLiteral("MozEdgeUICompleted")) { msg = eEdgeUICompleted; } else { return NS_ERROR_FAILURE; } WidgetSimpleGestureEvent event(true, msg, widget); event.mModifiers = nsContentUtils::GetWidgetModifiers(aModifiers); event.mDirection = aDirection; event.mDelta = aDelta; event.mClickCount = aClickCount; event.mTime = PR_IntervalNow(); nsPresContext* presContext = GetPresContext(); if (!presContext) return NS_ERROR_FAILURE; event.mRefPoint = nsContentUtils::ToWidgetPoint(CSSPoint(aX, aY), offset, presContext); nsEventStatus status; return widget->DispatchEvent(&event, status); } NS_IMETHODIMP nsDOMWindowUtils::ElementFromPoint(float aX, float aY, bool aIgnoreRootScrollFrame, bool aFlushLayout, nsIDOMElement** aReturn) { nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); Element* el = doc->ElementFromPointHelper(aX, aY, aIgnoreRootScrollFrame, aFlushLayout); nsCOMPtr retval = do_QueryInterface(el); retval.forget(aReturn); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::NodesFromRect(float aX, float aY, float aTopSize, float aRightSize, float aBottomSize, float aLeftSize, bool aIgnoreRootScrollFrame, bool aFlushLayout, nsIDOMNodeList** aReturn) { nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); return doc->NodesFromRectHelper(aX, aY, aTopSize, aRightSize, aBottomSize, aLeftSize, aIgnoreRootScrollFrame, aFlushLayout, aReturn); } NS_IMETHODIMP nsDOMWindowUtils::GetTranslationNodes(nsIDOMNode* aRoot, nsITranslationNodeList** aRetVal) { NS_ENSURE_ARG_POINTER(aRetVal); nsCOMPtr root = do_QueryInterface(aRoot); NS_ENSURE_STATE(root); nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); if (root->OwnerDoc() != doc) { return NS_ERROR_DOM_WRONG_DOCUMENT_ERR; } nsTHashtable> translationNodesHash(500); RefPtr list = new nsTranslationNodeList; uint32_t limit = 15000; // We begin iteration with content->GetNextNode because we want to explictly // skip the root tag from being a translation node. nsIContent* content = root; while ((limit > 0) && (content = content->GetNextNode(root))) { if (!content->IsHTMLElement()) { continue; } // Skip elements that usually contain non-translatable text content. if (content->IsAnyOfHTMLElements(nsGkAtoms::script, nsGkAtoms::iframe, nsGkAtoms::frameset, nsGkAtoms::frame, nsGkAtoms::code, nsGkAtoms::noscript, nsGkAtoms::style)) { continue; } // An element is a translation node if it contains // at least one text node that has meaningful data // for translation for (nsIContent* child = content->GetFirstChild(); child; child = child->GetNextSibling()) { if (child->IsText() && child->GetAsText()->HasTextForTranslation()) { translationNodesHash.PutEntry(content); bool isBlockFrame = false; nsIFrame* frame = content->GetPrimaryFrame(); if (frame) { isBlockFrame = frame->IsFrameOfType(nsIFrame::eBlockFrame); } bool isTranslationRoot = isBlockFrame; if (!isBlockFrame) { // If an element is not a block element, it still // can be considered a translation root if the parent // of this element didn't make into the list of nodes // to be translated. bool parentInList = false; nsIContent* parent = content->GetParent(); if (parent) { parentInList = translationNodesHash.Contains(parent); } isTranslationRoot = !parentInList; } list->AppendElement(content->AsDOMNode(), isTranslationRoot); --limit; break; } } } *aRetVal = list.forget().take(); return NS_OK; } static already_AddRefed CanvasToDataSourceSurface(HTMLCanvasElement* aCanvas) { MOZ_ASSERT(aCanvas); nsLayoutUtils::SurfaceFromElementResult result = nsLayoutUtils::SurfaceFromElement(aCanvas); MOZ_ASSERT(result.GetSourceSurface()); return result.GetSourceSurface()->GetDataSurface(); } NS_IMETHODIMP nsDOMWindowUtils::CompareCanvases(nsISupports *aCanvas1, nsISupports *aCanvas2, uint32_t* aMaxDifference, uint32_t* retVal) { if (aCanvas1 == nullptr || aCanvas2 == nullptr || retVal == nullptr) return NS_ERROR_FAILURE; nsCOMPtr contentCanvas1 = do_QueryInterface(aCanvas1); nsCOMPtr contentCanvas2 = do_QueryInterface(aCanvas2); auto canvas1 = HTMLCanvasElement::FromNodeOrNull(contentCanvas1); auto canvas2 = HTMLCanvasElement::FromNodeOrNull(contentCanvas2); if (!canvas1 || !canvas2) { return NS_ERROR_FAILURE; } RefPtr img1 = CanvasToDataSourceSurface(canvas1); RefPtr img2 = CanvasToDataSourceSurface(canvas2); if (img1->Equals(img2)) { // They point to the same underlying content. return NS_OK; } DataSourceSurface::ScopedMap map1(img1, DataSourceSurface::READ); DataSourceSurface::ScopedMap map2(img2, DataSourceSurface::READ); if (img1 == nullptr || img2 == nullptr || !map1.IsMapped() || !map2.IsMapped() || img1->GetSize() != img2->GetSize() || map1.GetStride() != map2.GetStride()) { return NS_ERROR_FAILURE; } int v; IntSize size = img1->GetSize(); int32_t stride = map1.GetStride(); // we can optimize for the common all-pass case if (stride == size.width * 4) { v = memcmp(map1.GetData(), map2.GetData(), size.width * size.height * 4); if (v == 0) { if (aMaxDifference) *aMaxDifference = 0; *retVal = 0; return NS_OK; } } uint32_t dc = 0; uint32_t different = 0; for (int j = 0; j < size.height; j++) { unsigned char *p1 = map1.GetData() + j*stride; unsigned char *p2 = map2.GetData() + j*stride; v = memcmp(p1, p2, stride); if (v) { for (int i = 0; i < size.width; i++) { if (*(uint32_t*) p1 != *(uint32_t*) p2) { different++; dc = std::max((uint32_t)abs(p1[0] - p2[0]), dc); dc = std::max((uint32_t)abs(p1[1] - p2[1]), dc); dc = std::max((uint32_t)abs(p1[2] - p2[2]), dc); dc = std::max((uint32_t)abs(p1[3] - p2[3]), dc); } p1 += 4; p2 += 4; } } } if (aMaxDifference) *aMaxDifference = dc; *retVal = different; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIsMozAfterPaintPending(bool *aResult) { NS_ENSURE_ARG_POINTER(aResult); *aResult = false; nsPresContext* presContext = GetPresContext(); if (!presContext) return NS_OK; *aResult = presContext->IsDOMPaintEventPending(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::DisableNonTestMouseEvents(bool aDisable) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsIDocShell *docShell = window->GetDocShell(); NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE); nsCOMPtr presShell = docShell->GetPresShell(); NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE); presShell->DisableNonTestMouseEvents(aDisable); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SuppressEventHandling(bool aSuppress) { nsCOMPtr doc = GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); if (aSuppress) { doc->SuppressEventHandling(); } else { doc->UnsuppressEventHandlingAndFireEvents(true); } return NS_OK; } static nsresult getScrollXYAppUnits(const nsWeakPtr& aWindow, bool aFlushLayout, nsPoint& aScrollPos) { nsCOMPtr window = do_QueryReferent(aWindow); nsCOMPtr doc = window ? window->GetExtantDoc() : nullptr; NS_ENSURE_STATE(doc); if (aFlushLayout) { doc->FlushPendingNotifications(FlushType::Layout); } nsIPresShell *presShell = doc->GetShell(); if (presShell) { nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable(); if (sf) { aScrollPos = sf->GetScrollPosition(); } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetScrollXY(bool aFlushLayout, int32_t* aScrollX, int32_t* aScrollY) { nsPoint scrollPos(0,0); nsresult rv = getScrollXYAppUnits(mWindow, aFlushLayout, scrollPos); NS_ENSURE_SUCCESS(rv, rv); *aScrollX = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.x); *aScrollY = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.y); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetScrollXYFloat(bool aFlushLayout, float* aScrollX, float* aScrollY) { nsPoint scrollPos(0,0); nsresult rv = getScrollXYAppUnits(mWindow, aFlushLayout, scrollPos); NS_ENSURE_SUCCESS(rv, rv); *aScrollX = nsPresContext::AppUnitsToFloatCSSPixels(scrollPos.x); *aScrollY = nsPresContext::AppUnitsToFloatCSSPixels(scrollPos.y); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetScrollbarSize(bool aFlushLayout, int32_t* aWidth, int32_t* aHeight) { *aWidth = 0; *aHeight = 0; nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); if (aFlushLayout) { doc->FlushPendingNotifications(FlushType::Layout); } nsIPresShell* presShell = doc->GetShell(); NS_ENSURE_TRUE(presShell, NS_ERROR_NOT_AVAILABLE); nsIScrollableFrame* scrollFrame = presShell->GetRootScrollFrameAsScrollable(); NS_ENSURE_TRUE(scrollFrame, NS_OK); nsMargin sizes = scrollFrame->GetActualScrollbarSizes(); *aWidth = nsPresContext::AppUnitsToIntCSSPixels(sizes.LeftRight()); *aHeight = nsPresContext::AppUnitsToIntCSSPixels(sizes.TopBottom()); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetBoundsWithoutFlushing(nsIDOMElement *aElement, DOMRect** aResult) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); nsresult rv; nsCOMPtr content = do_QueryInterface(aElement, &rv); NS_ENSURE_SUCCESS(rv, rv); RefPtr rect = new DOMRect(window); nsIFrame* frame = content->GetPrimaryFrame(); if (frame) { nsRect r = nsLayoutUtils::GetAllInFlowRectsUnion(frame, nsLayoutUtils::GetContainingBlockForClientRect(frame), nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS); rect->SetLayoutRect(r); } rect.forget(aResult); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::NeedsFlush(int32_t aFlushType, bool* aResult) { MOZ_ASSERT(aResult); nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); nsIPresShell* presShell = doc->GetShell(); NS_ENSURE_STATE(presShell); FlushType flushType; switch (aFlushType) { case FLUSH_STYLE: flushType = FlushType::Style; break; case FLUSH_LAYOUT: flushType = FlushType::Layout; break; case FLUSH_DISPLAY: flushType = FlushType::Display; break; default: return NS_ERROR_INVALID_ARG; } *aResult = presShell->NeedFlush(flushType); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::FlushLayoutWithoutThrottledAnimations() { nsCOMPtr doc = GetDocument(); if (doc) { doc->FlushPendingNotifications( ChangesToFlush(FlushType::Layout, false /* flush animations */)); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetRootBounds(DOMRect** aResult) { nsIDocument* doc = GetDocument(); NS_ENSURE_STATE(doc); nsRect bounds(0, 0, 0, 0); nsIPresShell* presShell = doc->GetShell(); if (presShell) { nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable(); if (sf) { bounds = sf->GetScrollRange(); bounds.SetWidth(bounds.Width() + sf->GetScrollPortRect().Width()); bounds.SetHeight(bounds.Height() + sf->GetScrollPortRect().Height()); } else if (presShell->GetRootFrame()) { bounds = presShell->GetRootFrame()->GetRect(); } } nsCOMPtr window = do_QueryReferent(mWindow); RefPtr rect = new DOMRect(window); rect->SetRect(nsPresContext::AppUnitsToFloatCSSPixels(bounds.x), nsPresContext::AppUnitsToFloatCSSPixels(bounds.y), nsPresContext::AppUnitsToFloatCSSPixels(bounds.Width()), nsPresContext::AppUnitsToFloatCSSPixels(bounds.Height())); rect.forget(aResult); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIMEIsOpen(bool *aState) { NS_ENSURE_ARG_POINTER(aState); nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; // Open state should not be available when IME is not enabled. InputContext context = widget->GetInputContext(); if (context.mIMEState.mEnabled != IMEState::ENABLED) { return NS_ERROR_NOT_AVAILABLE; } if (context.mIMEState.mOpen == IMEState::OPEN_STATE_NOT_SUPPORTED) { return NS_ERROR_NOT_IMPLEMENTED; } *aState = (context.mIMEState.mOpen == IMEState::OPEN); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIMEStatus(uint32_t *aState) { NS_ENSURE_ARG_POINTER(aState); nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; InputContext context = widget->GetInputContext(); *aState = static_cast(context.mIMEState.mEnabled); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFocusedInputType(nsAString& aType) { nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } aType = widget->GetInputContext().mHTMLInputType; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetViewId(nsIDOMElement* aElement, nsViewID* aResult) { nsCOMPtr content = do_QueryInterface(aElement); if (content && nsLayoutUtils::FindIDFor(content, aResult)) { return NS_OK; } return NS_ERROR_NOT_AVAILABLE; } NS_IMETHODIMP nsDOMWindowUtils::GetScreenPixelsPerCSSPixel(float* aScreenPixels) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); *aScreenPixels = window->GetDevicePixelRatio(CallerType::System); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFullZoom(float* aFullZoom) { *aFullZoom = 1.0f; nsPresContext* presContext = GetPresContext(); if (!presContext) { return NS_OK; } *aFullZoom = presContext->DeviceContext()->GetFullZoom(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::DispatchDOMEventViaPresShell(nsIDOMNode* aTarget, nsIDOMEvent* aEvent, bool aTrusted, bool* aRetVal) { NS_ENSURE_STATE(aEvent); aEvent->SetTrusted(aTrusted); WidgetEvent* internalEvent = aEvent->WidgetEventPtr(); NS_ENSURE_STATE(internalEvent); nsCOMPtr content = do_QueryInterface(aTarget); NS_ENSURE_STATE(content); nsCOMPtr window = do_QueryReferent(mWindow); if (content->OwnerDoc()->GetWindow() != window) { return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR; } nsCOMPtr targetDoc = content->GetUncomposedDoc(); NS_ENSURE_STATE(targetDoc); RefPtr targetShell = targetDoc->GetShell(); NS_ENSURE_STATE(targetShell); targetDoc->FlushPendingNotifications(FlushType::Layout); nsEventStatus status = nsEventStatus_eIgnore; targetShell->HandleEventWithTarget(internalEvent, nullptr, content, &status); *aRetVal = (status != nsEventStatus_eConsumeNoDefault); return NS_OK; } static void InitEvent(WidgetGUIEvent& aEvent, LayoutDeviceIntPoint* aPt = nullptr) { if (aPt) { aEvent.mRefPoint = *aPt; } aEvent.mTime = PR_IntervalNow(); } NS_IMETHODIMP nsDOMWindowUtils::SendQueryContentEvent(uint32_t aType, int64_t aOffset, uint32_t aLength, int32_t aX, int32_t aY, uint32_t aAdditionalFlags, nsIQueryContentEventResult **aResult) { *aResult = nullptr; nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsIDocShell *docShell = window->GetDocShell(); NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE); nsCOMPtr presShell = docShell->GetPresShell(); NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE); nsPresContext* presContext = presShell->GetPresContext(); NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE); // get the widget to send the event to nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } EventMessage message; switch (aType) { case QUERY_SELECTED_TEXT: message = eQuerySelectedText; break; case QUERY_TEXT_CONTENT: message = eQueryTextContent; break; case QUERY_CARET_RECT: message = eQueryCaretRect; break; case QUERY_TEXT_RECT: message = eQueryTextRect; break; case QUERY_EDITOR_RECT: message = eQueryEditorRect; break; case QUERY_CHARACTER_AT_POINT: message = eQueryCharacterAtPoint; break; case QUERY_TEXT_RECT_ARRAY: message = eQueryTextRectArray; break; default: return NS_ERROR_INVALID_ARG; } SelectionType selectionType = SelectionType::eNormal; static const uint32_t kSelectionFlags = QUERY_CONTENT_FLAG_SELECTION_SPELLCHECK | QUERY_CONTENT_FLAG_SELECTION_IME_RAWINPUT | QUERY_CONTENT_FLAG_SELECTION_IME_SELECTEDRAWTEXT | QUERY_CONTENT_FLAG_SELECTION_IME_CONVERTEDTEXT | QUERY_CONTENT_FLAG_SELECTION_IME_SELECTEDCONVERTEDTEXT | QUERY_CONTENT_FLAG_SELECTION_ACCESSIBILITY | QUERY_CONTENT_FLAG_SELECTION_FIND | QUERY_CONTENT_FLAG_SELECTION_URLSECONDARY | QUERY_CONTENT_FLAG_SELECTION_URLSTRIKEOUT; switch (aAdditionalFlags & kSelectionFlags) { case QUERY_CONTENT_FLAG_SELECTION_SPELLCHECK: selectionType = SelectionType::eSpellCheck; break; case QUERY_CONTENT_FLAG_SELECTION_IME_RAWINPUT: selectionType = SelectionType::eIMERawClause; break; case QUERY_CONTENT_FLAG_SELECTION_IME_SELECTEDRAWTEXT: selectionType = SelectionType::eIMESelectedRawClause; break; case QUERY_CONTENT_FLAG_SELECTION_IME_CONVERTEDTEXT: selectionType = SelectionType::eIMEConvertedClause; break; case QUERY_CONTENT_FLAG_SELECTION_IME_SELECTEDCONVERTEDTEXT: selectionType = SelectionType::eIMESelectedClause; break; case QUERY_CONTENT_FLAG_SELECTION_ACCESSIBILITY: selectionType = SelectionType::eAccessibility; break; case QUERY_CONTENT_FLAG_SELECTION_FIND: selectionType = SelectionType::eFind; break; case QUERY_CONTENT_FLAG_SELECTION_URLSECONDARY: selectionType = SelectionType::eURLSecondary; break; case QUERY_CONTENT_FLAG_SELECTION_URLSTRIKEOUT: selectionType = SelectionType::eURLStrikeout; break; case 0: break; default: return NS_ERROR_INVALID_ARG; } if (selectionType != SelectionType::eNormal && message != eQuerySelectedText) { return NS_ERROR_INVALID_ARG; } nsCOMPtr targetWidget = widget; LayoutDeviceIntPoint pt(aX, aY); WidgetQueryContentEvent::Options options; options.mUseNativeLineBreak = !(aAdditionalFlags & QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK); options.mRelativeToInsertionPoint = (aAdditionalFlags & QUERY_CONTENT_FLAG_OFFSET_RELATIVE_TO_INSERTION_POINT) != 0; if (options.mRelativeToInsertionPoint) { switch (message) { case eQueryTextContent: case eQueryCaretRect: case eQueryTextRect: break; default: return NS_ERROR_INVALID_ARG; } } else if (aOffset < 0) { return NS_ERROR_INVALID_ARG; } if (message == eQueryCharacterAtPoint) { // Looking for the widget at the point. WidgetQueryContentEvent dummyEvent(true, eQueryContentState, widget); dummyEvent.Init(options); InitEvent(dummyEvent, &pt); nsIFrame* popupFrame = nsLayoutUtils::GetPopupFrameForEventCoordinates(presContext->GetRootPresContext(), &dummyEvent); LayoutDeviceIntRect widgetBounds = widget->GetClientBounds(); widgetBounds.MoveTo(0, 0); // There is no popup frame at the point and the point isn't in our widget, // we cannot process this request. NS_ENSURE_TRUE(popupFrame || widgetBounds.Contains(pt), NS_ERROR_FAILURE); // Fire the event on the widget at the point if (popupFrame) { targetWidget = popupFrame->GetNearestWidget(); } } pt += widget->WidgetToScreenOffset() - targetWidget->WidgetToScreenOffset(); WidgetQueryContentEvent queryEvent(true, message, targetWidget); InitEvent(queryEvent, &pt); switch (message) { case eQueryTextContent: queryEvent.InitForQueryTextContent(aOffset, aLength, options); break; case eQueryCaretRect: queryEvent.InitForQueryCaretRect(aOffset, options); break; case eQueryTextRect: queryEvent.InitForQueryTextRect(aOffset, aLength, options); break; case eQuerySelectedText: queryEvent.InitForQuerySelectedText(selectionType, options); break; case eQueryTextRectArray: queryEvent.InitForQueryTextRectArray(aOffset, aLength, options); break; default: queryEvent.Init(options); break; } nsEventStatus status; nsresult rv = targetWidget->DispatchEvent(&queryEvent, status); NS_ENSURE_SUCCESS(rv, rv); auto* result = new nsQueryContentEventResult(); result->SetEventResult(widget, queryEvent); NS_ADDREF(*aResult = result); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendSelectionSetEvent(uint32_t aOffset, uint32_t aLength, uint32_t aAdditionalFlags, bool *aResult) { *aResult = false; // get the widget to send the event to nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } WidgetSelectionEvent selectionEvent(true, eSetSelection, widget); InitEvent(selectionEvent); selectionEvent.mOffset = aOffset; selectionEvent.mLength = aLength; selectionEvent.mReversed = (aAdditionalFlags & SELECTION_SET_FLAG_REVERSE); selectionEvent.mUseNativeLineBreak = !(aAdditionalFlags & SELECTION_SET_FLAG_USE_XP_LINE_BREAK); nsEventStatus status; nsresult rv = widget->DispatchEvent(&selectionEvent, status); NS_ENSURE_SUCCESS(rv, rv); *aResult = selectionEvent.mSucceeded; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendContentCommandEvent(const nsAString& aType, nsITransferable * aTransferable) { // get the widget to send the event to nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; EventMessage msg; if (aType.EqualsLiteral("cut")) { msg = eContentCommandCut; } else if (aType.EqualsLiteral("copy")) { msg = eContentCommandCopy; } else if (aType.EqualsLiteral("paste")) { msg = eContentCommandPaste; } else if (aType.EqualsLiteral("delete")) { msg = eContentCommandDelete; } else if (aType.EqualsLiteral("undo")) { msg = eContentCommandUndo; } else if (aType.EqualsLiteral("redo")) { msg = eContentCommandRedo; } else if (aType.EqualsLiteral("pasteTransferable")) { msg = eContentCommandPasteTransferable; } else { return NS_ERROR_FAILURE; } WidgetContentCommandEvent event(true, msg, widget); if (msg == eContentCommandPasteTransferable) { event.mTransferable = aTransferable; } nsEventStatus status; return widget->DispatchEvent(&event, status); } NS_IMETHODIMP nsDOMWindowUtils::GetClassName(JS::Handle aObject, JSContext* aCx, char** aName) { // Our argument must be a non-null object. if (aObject.isPrimitive()) { return NS_ERROR_XPC_BAD_CONVERT_JS; } *aName = NS_strdup(JS_GetClass(aObject.toObjectOrNull())->name); MOZ_ASSERT(*aName, "NS_strdup should be infallible."); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetVisitedDependentComputedStyle( nsIDOMElement *aElement, const nsAString& aPseudoElement, const nsAString& aPropertyName, nsAString& aResult) { aResult.Truncate(); nsCOMPtr window = do_QueryReferent(mWindow); nsCOMPtr element = do_QueryInterface(aElement); NS_ENSURE_STATE(window && element); nsCOMPtr innerWindow = window->GetCurrentInnerWindow(); NS_ENSURE_STATE(window); nsCOMPtr decl; { ErrorResult rv; decl = innerWindow->GetComputedStyle(*element, aPseudoElement, rv); ENSURE_SUCCESS(rv, rv.StealNSResult()); } static_cast(decl.get())->SetExposeVisitedStyle(true); nsresult rv = decl->GetPropertyValue(aPropertyName, aResult); static_cast(decl.get())->SetExposeVisitedStyle(false); return rv; } NS_IMETHODIMP nsDOMWindowUtils::EnterModalState() { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); window->EnterModalState(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::LeaveModalState() { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); window->LeaveModalState(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::IsInModalState(bool *retval) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); *retval = nsGlobalWindowOuter::Cast(window)->IsInModalState(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetDesktopModeViewport(bool aDesktopMode) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); window->SetDesktopModeViewport(aDesktopMode); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetOuterWindowID(uint64_t *aWindowID) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); *aWindowID = window->WindowID(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetCurrentInnerWindowID(uint64_t *aWindowID) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_NOT_AVAILABLE); nsGlobalWindowInner* inner = nsGlobalWindowOuter::Cast(window)->GetCurrentInnerWindowInternal(); if (!inner) { return NS_ERROR_NOT_AVAILABLE; } *aWindowID = inner->WindowID(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SuspendTimeouts() { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsCOMPtr inner = window->GetCurrentInnerWindow(); NS_ENSURE_TRUE(inner, NS_ERROR_FAILURE); inner->Suspend(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ResumeTimeouts() { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsCOMPtr inner = window->GetCurrentInnerWindow(); NS_ENSURE_TRUE(inner, NS_ERROR_FAILURE); inner->Resume(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetLayerManagerType(nsAString& aType) { nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; LayerManager *mgr = widget->GetLayerManager(nsIWidget::LAYER_MANAGER_PERSISTENT); if (!mgr) return NS_ERROR_FAILURE; mgr->GetBackendName(aType); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetLayerManagerRemote(bool* retval) { nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; LayerManager *mgr = widget->GetLayerManager(); if (!mgr) return NS_ERROR_FAILURE; *retval = !!mgr->AsKnowsCompositor(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetUsingAdvancedLayers(bool* retval) { nsCOMPtr widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } LayerManager *mgr = widget->GetLayerManager(); if (!mgr) { return NS_ERROR_FAILURE; } *retval = false; if (KnowsCompositor* fwd = mgr->AsKnowsCompositor()) { *retval = fwd->GetTextureFactoryIdentifier().mUsingAdvancedLayers; } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIsWebRenderRequested(bool* retval) { *retval = gfxPlatform::WebRenderPrefEnabled() || gfxPlatform::WebRenderEnvvarEnabled(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetCurrentAudioBackend(nsAString& aBackend) { CubebUtils::GetCurrentBackend(aBackend); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetCurrentMaxAudioChannels(uint32_t* aChannels) { *aChannels = CubebUtils::MaxNumberOfChannels(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetCurrentPreferredSampleRate(uint32_t* aRate) { *aRate = CubebUtils::PreferredSampleRate(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::AudioDevices(uint16_t aSide, nsIArray** aDevices) { NS_ENSURE_ARG_POINTER(aDevices); NS_ENSURE_ARG((aSide == AUDIO_INPUT) || (aSide == AUDIO_OUTPUT)); *aDevices = nullptr; nsresult rv = NS_OK; nsCOMPtr devices = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsTArray> collection; CubebUtils::GetDeviceCollection(collection, aSide == AUDIO_INPUT ? CubebUtils::Side::Input : CubebUtils::Side::Output); for (auto device: collection) { devices->AppendElement(device); } devices.forget(aDevices); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::StartFrameTimeRecording(uint32_t *startIndex) { NS_ENSURE_ARG_POINTER(startIndex); nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; LayerManager *mgr = widget->GetLayerManager(); if (!mgr) return NS_ERROR_FAILURE; const uint32_t kRecordingMinSize = 60 * 10; // 10 seconds @60 fps. const uint32_t kRecordingMaxSize = 60 * 60 * 60; // One hour uint32_t bufferSize = Preferences::GetUint("toolkit.framesRecording.bufferSize", uint32_t(0)); bufferSize = std::min(bufferSize, kRecordingMaxSize); bufferSize = std::max(bufferSize, kRecordingMinSize); *startIndex = mgr->StartFrameTimeRecording(bufferSize); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::StopFrameTimeRecording(uint32_t startIndex, uint32_t *frameCount, float **frameIntervals) { NS_ENSURE_ARG_POINTER(frameCount); NS_ENSURE_ARG_POINTER(frameIntervals); nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; LayerManager *mgr = widget->GetLayerManager(); if (!mgr) return NS_ERROR_FAILURE; nsTArray tmpFrameIntervals; mgr->StopFrameTimeRecording(startIndex, tmpFrameIntervals); *frameCount = tmpFrameIntervals.Length(); *frameIntervals = (float*)moz_xmalloc(*frameCount * sizeof(float)); /* copy over the frame intervals and paint times into the arrays we just allocated */ for (uint32_t i = 0; i < *frameCount; i++) { (*frameIntervals)[i] = tmpFrameIntervals[i]; } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::AdvanceTimeAndRefresh(int64_t aMilliseconds) { // Before we advance the time, we should trigger any animations that are // waiting to start. This is because there are many tests that call this // which expect animations to start immediately. Ideally, we should make // all these tests do an asynchronous wait on the corresponding animation's // 'ready' promise before continuing. Then we could remove the special // handling here and the code path followed when testing would more closely // match the code path during regular operation. Filed as bug 1112957. nsCOMPtr doc = GetDocument(); if (doc) { PendingAnimationTracker* tracker = doc->GetPendingAnimationTracker(); if (tracker) { tracker->TriggerPendingAnimationsNow(); } } nsPresContext* presContext = GetPresContext(); if (presContext) { nsRefreshDriver* driver = presContext->RefreshDriver(); driver->AdvanceTimeAndRefresh(aMilliseconds); RefPtr transaction = GetLayerTransaction(); if (transaction && transaction->IPCOpen()) { transaction->SendSetTestSampleTime(driver->MostRecentRefresh()); } else if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) { wrbc->SendSetTestSampleTime(driver->MostRecentRefresh()); } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetLastTransactionId(uint64_t *aLastTransactionId) { nsPresContext* presContext = GetPresContext(); if (!presContext) { return NS_ERROR_UNEXPECTED; } nsRefreshDriver* driver = presContext->GetRootPresContext()->RefreshDriver(); *aLastTransactionId = driver->LastTransactionId(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::RestoreNormalRefresh() { // Kick the compositor out of test mode before the refresh driver, so that // the refresh driver doesn't send an update that gets ignored by the // compositor. RefPtr transaction = GetLayerTransaction(); if (transaction && transaction->IPCOpen()) { transaction->SendLeaveTestMode(); } else if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) { wrbc->SendLeaveTestMode(); } if (nsPresContext* pc = GetPresContext()) { nsRefreshDriver* driver = pc->RefreshDriver(); driver->RestoreNormalRefresh(); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIsTestControllingRefreshes(bool *aResult) { nsPresContext* pc = GetPresContext(); *aResult = pc ? pc->RefreshDriver()->IsTestControllingRefreshesEnabled() : false; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetAsyncPanZoomEnabled(bool *aResult) { nsIWidget* widget = GetWidget(); if (widget) { *aResult = widget->AsyncPanZoomEnabled(); } else { *aResult = gfxPlatform::AsyncPanZoomEnabled(); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetAsyncScrollOffset(nsIDOMNode* aNode, float aX, float aY) { nsCOMPtr element = do_QueryInterface(aNode); if (!element) { return NS_ERROR_INVALID_ARG; } FrameMetrics::ViewID viewId; if (!nsLayoutUtils::FindIDFor(element, &viewId)) { return NS_ERROR_UNEXPECTED; } nsIWidget* widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } LayerManager* manager = widget->GetLayerManager(); if (!manager) { return NS_ERROR_FAILURE; } if (WebRenderLayerManager* wrlm = manager->AsWebRenderLayerManager()) { WebRenderBridgeChild* wrbc = wrlm->WrBridge(); if (!wrbc) { return NS_ERROR_UNEXPECTED; } wrbc->SendSetAsyncScrollOffset(viewId, aX, aY); return NS_OK; } ShadowLayerForwarder* forwarder = manager->AsShadowForwarder(); if (!forwarder || !forwarder->HasShadowManager()) { return NS_ERROR_UNEXPECTED; } forwarder->GetShadowManager()->SendSetAsyncScrollOffset(viewId, aX, aY); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetAsyncZoom(nsIDOMNode* aRootElement, float aValue) { nsCOMPtr element = do_QueryInterface(aRootElement); if (!element) { return NS_ERROR_INVALID_ARG; } FrameMetrics::ViewID viewId; if (!nsLayoutUtils::FindIDFor(element, &viewId)) { return NS_ERROR_UNEXPECTED; } nsIWidget* widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } LayerManager* manager = widget->GetLayerManager(); if (!manager) { return NS_ERROR_FAILURE; } if (WebRenderLayerManager* wrlm = manager->AsWebRenderLayerManager()) { WebRenderBridgeChild* wrbc = wrlm->WrBridge(); if (!wrbc) { return NS_ERROR_UNEXPECTED; } wrbc->SendSetAsyncZoom(viewId, aValue); return NS_OK; } ShadowLayerForwarder* forwarder = manager->AsShadowForwarder(); if (!forwarder || !forwarder->HasShadowManager()) { return NS_ERROR_UNEXPECTED; } forwarder->GetShadowManager()->SendSetAsyncZoom(viewId, aValue); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::FlushApzRepaints(bool* aOutResult) { nsIWidget* widget = GetWidget(); if (!widget) { *aOutResult = false; return NS_OK; } // If APZ is not enabled, this function is a no-op. if (!widget->AsyncPanZoomEnabled()) { *aOutResult = false; return NS_OK; } LayerManager* manager = widget->GetLayerManager(); if (!manager) { *aOutResult = false; return NS_OK; } if (WebRenderLayerManager* wrlm = manager->AsWebRenderLayerManager()) { WebRenderBridgeChild* wrbc = wrlm->WrBridge(); if (!wrbc) { return NS_ERROR_UNEXPECTED; } wrbc->SendFlushApzRepaints(); *aOutResult = true; return NS_OK; } ShadowLayerForwarder* forwarder = manager->AsShadowForwarder(); if (!forwarder || !forwarder->HasShadowManager()) { *aOutResult = false; return NS_OK; } forwarder->GetShadowManager()->SendFlushApzRepaints(); *aOutResult = true; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ZoomToFocusedInput() { nsIWidget* widget = GetWidget(); if (!widget) { return NS_OK; } // If APZ is not enabled, this function is a no-op. if (!widget->AsyncPanZoomEnabled()) { return NS_OK; } nsFocusManager* fm = nsFocusManager::GetFocusManager(); if (!fm) { return NS_OK; } nsIContent* content = fm->GetFocusedContent(); if (!content) { return NS_OK; } nsIPresShell* shell = APZCCallbackHelper::GetRootContentDocumentPresShellForContent(content); if (!shell) { return NS_OK; } nsIScrollableFrame* rootScrollFrame = shell->GetRootScrollFrameAsScrollable(); if (!rootScrollFrame) { return NS_OK; } nsIFrame* currentFrame = content->GetPrimaryFrame(); nsIFrame* rootFrame = shell->GetRootFrame(); nsIFrame* scrolledFrame = rootScrollFrame->GetScrolledFrame(); bool isFixedPos = true; while (currentFrame) { if (currentFrame == rootFrame) { break; } if (currentFrame == scrolledFrame) { // we are in the rootScrollFrame so this element is not fixed isFixedPos = false; break; } currentFrame = nsLayoutUtils::GetCrossDocParentFrame(currentFrame); } if (isFixedPos) { // We didn't find the scrolledFrame in our parent frames so this content must be fixed position. // Zooming into fixed position content doesn't make sense so just return with out panning and zooming. return NS_OK; } nsIDocument* document = shell->GetDocument(); if (!document) { return NS_OK; } uint32_t presShellId; FrameMetrics::ViewID viewId; if (APZCCallbackHelper::GetOrCreateScrollIdentifiers(document->GetDocumentElement(), &presShellId, &viewId)) { uint32_t flags = layers::DISABLE_ZOOM_OUT; if (!Preferences::GetBool("formhelper.autozoom")) { flags |= layers::PAN_INTO_VIEW_ONLY; } else { flags |= layers::ONLY_ZOOM_TO_DEFAULT_SCALE; } CSSRect bounds = nsLayoutUtils::GetBoundingContentRect(content, rootScrollFrame); if (bounds.IsEmpty()) { // Do not zoom on empty bounds. Bail out. return NS_OK; } bounds.Inflate(15.0f, 0.0f); widget->ZoomToRect(presShellId, viewId, bounds, flags); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ComputeAnimationDistance(nsIDOMElement* aElement, const nsAString& aProperty, const nsAString& aValue1, const nsAString& aValue2, double* aResult) { nsresult rv; nsCOMPtr content = do_QueryInterface(aElement, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCSSPropertyID property = nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eIgnoreEnabledState); if (property == eCSSProperty_UNKNOWN || nsCSSProps::IsShorthand(property)) { return NS_ERROR_ILLEGAL_VALUE; } Element* element = content->AsElement(); AnimationValue v1 = AnimationValue::FromString(property, aValue1, element); AnimationValue v2 = AnimationValue::FromString(property, aValue2, element); if (v1.IsNull() || v2.IsNull()) { return NS_ERROR_ILLEGAL_VALUE; } RefPtr computedStyle = nsComputedDOMStyle::GetComputedStyle(element, nullptr); *aResult = v1.ComputeDistance(property, v2, computedStyle); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetAnimationTypeForLonghand(const nsAString& aProperty, nsAString& aResult) { nsCSSPropertyID propertyID = nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eForAllContent); if (propertyID == eCSSProperty_UNKNOWN) { return NS_ERROR_INVALID_ARG; } if (nsCSSProps::IsShorthand(propertyID)) { // The given property should be a longhand. return NS_ERROR_INVALID_ARG; } switch (nsCSSProps::kAnimTypeTable[propertyID]) { case eStyleAnimType_Custom: aResult.AssignLiteral("custom"); break; case eStyleAnimType_Coord: case eStyleAnimType_Sides_Top: case eStyleAnimType_Sides_Right: case eStyleAnimType_Sides_Bottom: case eStyleAnimType_Sides_Left: case eStyleAnimType_Corner_TopLeft: case eStyleAnimType_Corner_TopRight: case eStyleAnimType_Corner_BottomRight: case eStyleAnimType_Corner_BottomLeft: aResult.AssignLiteral("coord"); break; case eStyleAnimType_nscoord: aResult.AssignLiteral("length"); break; case eStyleAnimType_float: aResult.AssignLiteral("float"); break; case eStyleAnimType_Color: case eStyleAnimType_ComplexColor: aResult.AssignLiteral("color"); break; case eStyleAnimType_PaintServer: aResult.AssignLiteral("paintServer"); break; case eStyleAnimType_Shadow: aResult.AssignLiteral("shadow"); break; case eStyleAnimType_Discrete: aResult.AssignLiteral("discrete"); break; case eStyleAnimType_None: aResult.AssignLiteral("none"); break; } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetUnanimatedComputedStyle(nsIDOMElement* aElement, const nsAString& aPseudoElement, const nsAString& aProperty, int32_t aFlushType, nsAString& aResult) { nsCOMPtr element = do_QueryInterface(aElement); if (!element) { return NS_ERROR_INVALID_ARG; } nsCSSPropertyID propertyID = nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eForAllContent); if (propertyID == eCSSProperty_UNKNOWN || nsCSSProps::IsShorthand(propertyID)) { return NS_ERROR_INVALID_ARG; } switch (aFlushType) { case FLUSH_NONE: break; case FLUSH_STYLE: { if (nsIDocument* doc = element->GetComposedDoc()) { doc->FlushPendingNotifications(FlushType::Style); } break; } default: return NS_ERROR_INVALID_ARG; } nsIPresShell* shell = GetPresShell(); if (!shell) { return NS_ERROR_FAILURE; } RefPtr pseudo = nsCSSPseudoElements::GetPseudoAtom(aPseudoElement); RefPtr computedStyle = nsComputedDOMStyle::GetUnanimatedComputedStyleNoFlush(element, pseudo); if (!computedStyle) { return NS_ERROR_FAILURE; } RefPtr value = Servo_ComputedValues_ExtractAnimationValue(computedStyle, propertyID).Consume(); if (!value) { return NS_ERROR_FAILURE; } Servo_AnimationValue_Serialize(value, propertyID, &aResult); return NS_OK; } nsresult nsDOMWindowUtils::RenderDocument(const nsRect& aRect, uint32_t aFlags, nscolor aBackgroundColor, gfxContext* aThebesContext) { nsCOMPtr doc = GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); // Get Primary Shell nsCOMPtr presShell = doc->GetShell(); NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE); // Render Document return presShell->RenderDocument(aRect, aFlags, aBackgroundColor, aThebesContext); } NS_IMETHODIMP nsDOMWindowUtils::GetDisplayDPI(float *aDPI) { nsCOMPtr widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; *aDPI = widget->GetDPI(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetContainerElement(nsIDOMElement** aResult) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); nsCOMPtr element = do_QueryInterface(window->GetFrameElementInternal()); element.forget(aResult); return NS_OK; } #ifdef DEBUG static bool CheckLeafLayers(Layer* aLayer, const nsIntPoint& aOffset, nsIntRegion* aCoveredRegion) { gfx::Matrix transform; if (!aLayer->GetTransform().Is2D(&transform) || transform.HasNonIntegerTranslation()) return false; transform.NudgeToIntegers(); IntPoint offset = aOffset + IntPoint::Truncate(transform._31, transform._32); Layer* child = aLayer->GetFirstChild(); if (child) { while (child) { if (!CheckLeafLayers(child, offset, aCoveredRegion)) return false; child = child->GetNextSibling(); } } else { nsIntRegion rgn = aLayer->GetVisibleRegion().ToUnknownRegion(); rgn.MoveBy(offset); nsIntRegion tmp; tmp.And(rgn, *aCoveredRegion); if (!tmp.IsEmpty()) return false; aCoveredRegion->Or(*aCoveredRegion, rgn); } return true; } #endif NS_IMETHODIMP nsDOMWindowUtils::LeafLayersPartitionWindow(bool* aResult) { *aResult = true; #ifdef DEBUG nsIWidget* widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; LayerManager* manager = widget->GetLayerManager(); if (!manager) return NS_ERROR_FAILURE; nsPresContext* presContext = GetPresContext(); if (!presContext) return NS_ERROR_FAILURE; Layer* root = manager->GetRoot(); if (!root) return NS_ERROR_FAILURE; nsIntPoint offset(0, 0); nsIntRegion coveredRegion; if (!CheckLeafLayers(root, offset, &coveredRegion)) { *aResult = false; } if (!coveredRegion.IsEqual(root->GetVisibleRegion().ToUnknownRegion())) { *aResult = false; } #endif return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::CheckAndClearPaintedState(nsIDOMElement* aElement, bool* aResult) { if (!aElement) { return NS_ERROR_INVALID_ARG; } nsresult rv; nsCOMPtr content = do_QueryInterface(aElement, &rv); NS_ENSURE_SUCCESS(rv, rv); nsIFrame* frame = content->GetPrimaryFrame(); if (!frame) { *aResult = false; return NS_OK; } // Get the outermost frame for the content node, so that we can test // canvasframe invalidations by observing the documentElement. for (;;) { nsIFrame* parentFrame = frame->GetParent(); if (parentFrame && parentFrame->GetContent() == content) { frame = parentFrame; } else { break; } } *aResult = frame->CheckAndClearPaintedState(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::CheckAndClearDisplayListState(nsIDOMElement* aElement, bool* aResult) { if (!aElement) { return NS_ERROR_INVALID_ARG; } nsresult rv; nsCOMPtr content = do_QueryInterface(aElement, &rv); NS_ENSURE_SUCCESS(rv, rv); nsIFrame* frame = content->GetPrimaryFrame(); if (!frame) { *aResult = false; return NS_OK; } // Get the outermost frame for the content node, so that we can test // canvasframe invalidations by observing the documentElement. for (;;) { nsIFrame* parentFrame = frame->GetParent(); if (parentFrame && parentFrame->GetContent() == content) { frame = parentFrame; } else { break; } } *aResult = frame->CheckAndClearDisplayListState(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::IsPartOfOpaqueLayer(nsIDOMElement* aElement, bool* aResult) { if (!aElement) { return NS_ERROR_INVALID_ARG; } nsresult rv; nsCOMPtr content = do_QueryInterface(aElement, &rv); NS_ENSURE_SUCCESS(rv, rv); nsIFrame* frame = content->GetPrimaryFrame(); if (!frame) { return NS_ERROR_FAILURE; } ColorLayer* colorLayer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame(frame); if (colorLayer) { auto color = colorLayer->GetColor(); *aResult = color.a == 1.0f; return NS_OK; } PaintedLayer* paintedLayer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame(frame); if (paintedLayer) { *aResult = paintedLayer->IsOpaque(); return NS_OK; } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDOMWindowUtils::NumberOfAssignedPaintedLayers(nsIDOMElement** aElements, uint32_t aCount, uint32_t* aResult) { if (!aElements) { return NS_ERROR_INVALID_ARG; } nsTHashtable> layers; nsresult rv; for (uint32_t i = 0; i < aCount; i++) { nsCOMPtr content = do_QueryInterface(aElements[i], &rv); NS_ENSURE_SUCCESS(rv, rv); nsIFrame* frame = content->GetPrimaryFrame(); if (!frame) { return NS_ERROR_FAILURE; } PaintedLayer* layer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame(frame); if (!layer) { return NS_ERROR_FAILURE; } layers.PutEntry(layer); } *aResult = layers.Count(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::EnableDialogs() { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsGlobalWindowOuter::Cast(window)->EnableDialogs(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::DisableDialogs() { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsGlobalWindowOuter::Cast(window)->DisableDialogs(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::AreDialogsEnabled(bool* aResult) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); *aResult = nsGlobalWindowOuter::Cast(window)->AreDialogsEnabled(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFileId(JS::Handle aFile, JSContext* aCx, int64_t* _retval) { if (aFile.isPrimitive()) { *_retval = -1; return NS_OK; } JS::Rooted obj(aCx, aFile.toObjectOrNull()); IDBMutableFile* mutableFile = nullptr; if (NS_SUCCEEDED(UNWRAP_OBJECT(IDBMutableFile, &obj, mutableFile))) { *_retval = mutableFile->GetFileId(); return NS_OK; } Blob* blob = nullptr; if (NS_SUCCEEDED(UNWRAP_OBJECT(Blob, &obj, blob))) { *_retval = blob->GetFileId(); return NS_OK; } *_retval = -1; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFilePath(JS::HandleValue aFile, JSContext* aCx, nsAString& _retval) { if (aFile.isPrimitive()) { _retval.Truncate(); return NS_OK; } JS::Rooted obj(aCx, aFile.toObjectOrNull()); File* file = nullptr; if (NS_SUCCEEDED(UNWRAP_OBJECT(File, &obj, file))) { nsString filePath; ErrorResult rv; file->GetMozFullPathInternal(filePath, rv); if (NS_WARN_IF(rv.Failed())) { return rv.StealNSResult(); } _retval = filePath; return NS_OK; } _retval.Truncate(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFileReferences(const nsAString& aDatabaseName, int64_t aId, JS::Handle aOptions, int32_t* aRefCnt, int32_t* aDBRefCnt, int32_t* aSliceRefCnt, JSContext* aCx, bool* aResult) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsCString origin; nsresult rv = quota::QuotaManager::GetInfoFromWindow(window, nullptr, nullptr, &origin); NS_ENSURE_SUCCESS(rv, rv); IDBOpenDBOptions options; JS::Rooted optionsVal(aCx, aOptions); if (!options.Init(aCx, optionsVal)) { return NS_ERROR_TYPE_ERR; } quota::PersistenceType persistenceType = quota::PersistenceTypeFromStorage(options.mStorage); RefPtr mgr = IndexedDatabaseManager::Get(); if (mgr) { rv = mgr->BlockAndGetFileReferences(persistenceType, origin, aDatabaseName, aId, aRefCnt, aDBRefCnt, aSliceRefCnt, aResult); NS_ENSURE_SUCCESS(rv, rv); } else { *aRefCnt = *aDBRefCnt = *aSliceRefCnt = -1; *aResult = false; } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::FlushPendingFileDeletions() { RefPtr mgr = IndexedDatabaseManager::Get(); if (mgr) { nsresult rv = mgr->FlushPendingFileDeletions(); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::IsIncrementalGCEnabled(JSContext* cx, bool* aResult) { *aResult = JS::IsIncrementalGCEnabled(cx); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::StartPCCountProfiling(JSContext* cx) { js::StartPCCountProfiling(cx); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::StopPCCountProfiling(JSContext* cx) { js::StopPCCountProfiling(cx); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::PurgePCCounts(JSContext* cx) { js::PurgePCCounts(cx); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetPCCountScriptCount(JSContext* cx, int32_t *result) { *result = js::GetPCCountScriptCount(cx); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetPCCountScriptSummary(int32_t script, JSContext* cx, nsAString& result) { JSString *text = js::GetPCCountScriptSummary(cx, script); if (!text) return NS_ERROR_FAILURE; if (!AssignJSString(cx, result, text)) return NS_ERROR_FAILURE; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetPCCountScriptContents(int32_t script, JSContext* cx, nsAString& result) { JSString *text = js::GetPCCountScriptContents(cx, script); if (!text) return NS_ERROR_FAILURE; if (!AssignJSString(cx, result, text)) return NS_ERROR_FAILURE; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetPaintingSuppressed(bool *aPaintingSuppressed) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsIDocShell *docShell = window->GetDocShell(); NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE); nsCOMPtr presShell = docShell->GetPresShell(); NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE); *aPaintingSuppressed = presShell->IsPaintingSuppressed(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetPlugins(JSContext* cx, JS::MutableHandle aPlugins) { nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); nsTArray plugins; doc->GetPlugins(plugins); JS::Rooted jsPlugins(cx); nsresult rv = nsTArrayToJSArray(cx, plugins, &jsPlugins); NS_ENSURE_SUCCESS(rv, rv); aPlugins.setObject(*jsPlugins); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetScrollPositionClampingScrollPortSize(float aWidth, float aHeight) { if (!(aWidth >= 0.0 && aHeight >= 0.0)) { return NS_ERROR_ILLEGAL_VALUE; } nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } nsLayoutUtils::SetScrollPositionClampingScrollPortSize(presShell, CSSSize(aWidth, aHeight)); return NS_OK; } nsresult nsDOMWindowUtils::RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement) { nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); doc->RemoteFrameFullscreenChanged(aFrameElement); return NS_OK; } nsresult nsDOMWindowUtils::RemoteFrameFullscreenReverted() { nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); doc->RemoteFrameFullscreenReverted(); return NS_OK; } static void PrepareForFullscreenChange(nsIPresShell* aPresShell, const nsSize& aSize, nsSize* aOldSize = nullptr) { if (!aPresShell) { return; } if (nsRefreshDriver* rd = aPresShell->GetRefreshDriver()) { rd->SetIsResizeSuppressed(); // Since we are suppressing the resize reflow which would originally // be triggered by view manager, we need to ensure that the refresh // driver actually schedules a flush, otherwise it may get stuck. rd->ScheduleViewManagerFlush(); } if (!aSize.IsEmpty()) { if (nsViewManager* viewManager = aPresShell->GetViewManager()) { if (aOldSize) { viewManager->GetWindowDimensions(&aOldSize->width, &aOldSize->height); } viewManager->SetWindowDimensions(aSize.width, aSize.height); } } } NS_IMETHODIMP nsDOMWindowUtils::HandleFullscreenRequests(bool* aRetVal) { PROFILER_ADD_MARKER("Enter fullscreen"); nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); // Notify the pres shell that we are starting fullscreen change, and // set the window dimensions in advance. Since the resize message // comes after the fullscreen change call, doing so could avoid an // extra resize reflow after this point. nsRect screenRect; if (nsPresContext* presContext = GetPresContext()) { presContext->DeviceContext()->GetRect(screenRect); } nsSize oldSize; PrepareForFullscreenChange(GetPresShell(), screenRect.Size(), &oldSize); OldWindowSize::Set(mWindow, oldSize); *aRetVal = nsIDocument::HandlePendingFullscreenRequests(doc); return NS_OK; } nsresult nsDOMWindowUtils::ExitFullscreen() { PROFILER_ADD_MARKER("Exit fullscreen"); nsCOMPtr doc = GetDocument(); NS_ENSURE_STATE(doc); // Although we would not use the old size if we have already exited // fullscreen, we still want to cleanup in case we haven't. nsSize oldSize = OldWindowSize::GetAndRemove(mWindow); if (!doc->GetFullscreenElement()) { return NS_OK; } // Notify the pres shell that we are starting fullscreen change, and // set the window dimensions in advance. Since the resize message // comes after the fullscreen change call, doing so could avoid an // extra resize reflow after this point. PrepareForFullscreenChange(GetPresShell(), oldSize); nsIDocument::ExitFullscreenInDocTree(doc); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SelectAtPoint(float aX, float aY, uint32_t aSelectBehavior, bool *_retval) { *_retval = false; nsSelectionAmount amount; switch (aSelectBehavior) { case nsIDOMWindowUtils::SELECT_CHARACTER: amount = eSelectCharacter; break; case nsIDOMWindowUtils::SELECT_CLUSTER: amount = eSelectCluster; break; case nsIDOMWindowUtils::SELECT_WORD: amount = eSelectWord; break; case nsIDOMWindowUtils::SELECT_LINE: amount = eSelectLine; break; case nsIDOMWindowUtils::SELECT_BEGINLINE: amount = eSelectBeginLine; break; case nsIDOMWindowUtils::SELECT_ENDLINE: amount = eSelectEndLine; break; case nsIDOMWindowUtils::SELECT_PARAGRAPH: amount = eSelectParagraph; break; case nsIDOMWindowUtils::SELECT_WORDNOSPACE: amount = eSelectWordNoSpace; break; default: return NS_ERROR_INVALID_ARG; } nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_UNEXPECTED; } // The root frame for this content window nsIFrame* rootFrame = presShell->GetRootFrame(); if (!rootFrame) { return NS_ERROR_UNEXPECTED; } // Get the target frame at the client coordinates passed to us nsPoint offset; nsCOMPtr widget = GetWidget(&offset); LayoutDeviceIntPoint pt = nsContentUtils::ToWidgetPoint(CSSPoint(aX, aY), offset, GetPresContext()); nsPoint ptInRoot = nsLayoutUtils::GetEventCoordinatesRelativeTo(widget, pt, rootFrame); nsIFrame* targetFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, ptInRoot); // This can happen if the page hasn't loaded yet or if the point // is outside the frame. if (!targetFrame) { return NS_ERROR_INVALID_ARG; } // Convert point to coordinates relative to the target frame, which is // what targetFrame's SelectByTypeAtPoint expects. nsPoint relPoint = nsLayoutUtils::GetEventCoordinatesRelativeTo(widget, pt, targetFrame); nsresult rv = static_cast(targetFrame)-> SelectByTypeAtPoint(GetPresContext(), relPoint, amount, amount, nsFrame::SELECT_ACCUMULATE); *_retval = !NS_FAILED(rv); return NS_OK; } static nsIDocument::additionalSheetType convertSheetType(uint32_t aSheetType) { switch(aSheetType) { case nsDOMWindowUtils::AGENT_SHEET: return nsIDocument::eAgentSheet; case nsDOMWindowUtils::USER_SHEET: return nsIDocument::eUserSheet; case nsDOMWindowUtils::AUTHOR_SHEET: return nsIDocument::eAuthorSheet; default: NS_ASSERTION(false, "wrong type"); // we must return something although this should never happen return nsIDocument::AdditionalSheetTypeCount; } } NS_IMETHODIMP nsDOMWindowUtils::LoadSheet(nsIURI *aSheetURI, uint32_t aSheetType) { NS_ENSURE_ARG_POINTER(aSheetURI); NS_ENSURE_ARG(aSheetType == AGENT_SHEET || aSheetType == USER_SHEET || aSheetType == AUTHOR_SHEET); nsCOMPtr doc = GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); nsIDocument::additionalSheetType type = convertSheetType(aSheetType); return doc->LoadAdditionalStyleSheet(type, aSheetURI); } NS_IMETHODIMP nsDOMWindowUtils::LoadSheetUsingURIString(const nsACString& aSheetURI, uint32_t aSheetType) { nsCOMPtr uri; nsresult rv = NS_NewURI(getter_AddRefs(uri), aSheetURI); NS_ENSURE_SUCCESS(rv, rv); return LoadSheet(uri, aSheetType); } NS_IMETHODIMP nsDOMWindowUtils::AddSheet(nsIPreloadedStyleSheet* aSheet, uint32_t aSheetType) { NS_ENSURE_ARG_POINTER(aSheet); NS_ENSURE_ARG(aSheetType == AGENT_SHEET || aSheetType == USER_SHEET || aSheetType == AUTHOR_SHEET); nsCOMPtr doc = GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); StyleSheet* sheet = nullptr; auto preloadedSheet = static_cast(aSheet); nsresult rv = preloadedSheet->GetSheet(&sheet); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(sheet, NS_ERROR_FAILURE); if (sheet->GetAssociatedDocument()) { return NS_ERROR_INVALID_ARG; } nsIDocument::additionalSheetType type = convertSheetType(aSheetType); return doc->AddAdditionalStyleSheet(type, sheet); } NS_IMETHODIMP nsDOMWindowUtils::RemoveSheet(nsIURI *aSheetURI, uint32_t aSheetType) { NS_ENSURE_ARG_POINTER(aSheetURI); NS_ENSURE_ARG(aSheetType == AGENT_SHEET || aSheetType == USER_SHEET || aSheetType == AUTHOR_SHEET); nsCOMPtr doc = GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); nsIDocument::additionalSheetType type = convertSheetType(aSheetType); doc->RemoveAdditionalStyleSheet(type, aSheetURI); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::RemoveSheetUsingURIString(const nsACString& aSheetURI, uint32_t aSheetType) { nsCOMPtr uri; nsresult rv = NS_NewURI(getter_AddRefs(uri), aSheetURI); NS_ENSURE_SUCCESS(rv, rv); return RemoveSheet(uri, aSheetType); } NS_IMETHODIMP nsDOMWindowUtils::GetIsHandlingUserInput(bool* aHandlingUserInput) { *aHandlingUserInput = EventStateManager::IsHandlingUserInput(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetMillisSinceLastUserInput(double* aMillisSinceLastUserInput) { TimeStamp lastInput = EventStateManager::LatestUserInputStart(); if (lastInput.IsNull()) { *aMillisSinceLastUserInput = -1.0f; return NS_OK; } *aMillisSinceLastUserInput = (TimeStamp::Now() - lastInput).ToMilliseconds(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::AllowScriptsToClose() { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); nsGlobalWindowOuter::Cast(window)->AllowScriptsToClose(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIsParentWindowMainWidgetVisible(bool* aIsVisible) { // this should reflect the "is parent window visible" logic in // nsWindowWatcher::OpenWindowInternal() nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); nsCOMPtr parentWidget; nsIDocShell *docShell = window->GetDocShell(); if (docShell) { if (TabChild *tabChild = TabChild::GetFrom(docShell)) { if (!tabChild->SendIsParentWindowMainWidgetVisible(aIsVisible)) return NS_ERROR_FAILURE; return NS_OK; } nsCOMPtr parentTreeOwner; docShell->GetTreeOwner(getter_AddRefs(parentTreeOwner)); nsCOMPtr parentWindow(do_GetInterface(parentTreeOwner)); if (parentWindow) { parentWindow->GetMainWidget(getter_AddRefs(parentWidget)); } } if (!parentWidget) { return NS_ERROR_NOT_AVAILABLE; } *aIsVisible = parentWidget->IsVisible(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::IsNodeDisabledForEvents(nsIDOMNode* aNode, bool* aRetVal) { *aRetVal = false; nsCOMPtr n = do_QueryInterface(aNode); nsINode* node = n; while (node) { if (node->IsNodeOfType(nsINode::eHTML_FORM_CONTROL)) { nsCOMPtr fc = do_QueryInterface(node); if (fc && fc->IsDisabledForEvents(eVoidEvent)) { *aRetVal = true; break; } } node = node->GetParentNode(); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetPaintFlashing(bool aPaintFlashing) { nsPresContext* presContext = GetPresContext(); if (presContext) { presContext->SetPaintFlashing(aPaintFlashing); // Clear paint flashing colors nsIPresShell* presShell = GetPresShell(); if (!aPaintFlashing && presShell) { nsIFrame* rootFrame = presShell->GetRootFrame(); if (rootFrame) { rootFrame->InvalidateFrameSubtree(); } } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetPaintFlashing(bool* aRetVal) { *aRetVal = false; nsPresContext* presContext = GetPresContext(); if (presContext) { *aRetVal = presContext->GetPaintFlashing(); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::DispatchEventToChromeOnly(nsIDOMEventTarget* aTarget, nsIDOMEvent* aEvent, bool* aRetVal) { *aRetVal = false; NS_ENSURE_STATE(aTarget && aEvent); aEvent->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true; *aRetVal = EventTarget::From(aTarget)-> DispatchEvent(*aEvent->InternalDOMEvent(), CallerType::System, IgnoreErrors()); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::RequestCompositorProperty(const nsAString& property, float* aResult) { if (nsIWidget* widget = GetWidget()) { mozilla::layers::LayerManager* manager = widget->GetLayerManager(); if (manager) { *aResult = manager->RequestProperty(property); return NS_OK; } } return NS_ERROR_NOT_AVAILABLE; } NS_IMETHODIMP nsDOMWindowUtils::GetOMTAStyle(nsIDOMElement* aElement, const nsAString& aProperty, const nsAString& aPseudoElement, nsAString& aResult) { nsCOMPtr element = do_QueryInterface(aElement); if (!element) { return NS_ERROR_INVALID_ARG; } RefPtr cssValue = nullptr; nsIFrame* frame = element->GetPrimaryFrame(); if (!aPseudoElement.IsEmpty()) { if (aPseudoElement.EqualsLiteral("::before")) { frame = nsLayoutUtils::GetBeforeFrame(element); } else if (aPseudoElement.EqualsLiteral("::after")) { frame = nsLayoutUtils::GetAfterFrame(element); } else { return NS_ERROR_INVALID_ARG; } } if (frame && nsLayoutUtils::AreAsyncAnimationsEnabled()) { RefPtr widgetLayerManager; if (nsIWidget* widget = GetWidget()) { widgetLayerManager = widget->GetLayerManager(); } if (aProperty.EqualsLiteral("opacity")) { float value = 0; bool hadAnimatedOpacity = false; Layer* layer = FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_OPACITY); if (layer) { ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder(); if (forwarder && forwarder->HasShadowManager()) { forwarder->GetShadowManager()-> SendGetAnimationOpacity(layer->GetCompositorAnimationsId(), &value, &hadAnimatedOpacity); } } else if (WebRenderLayerManager* wrlm = widgetLayerManager->AsWebRenderLayerManager()) { RefPtr animationData = GetWebRenderUserData(frame, (uint32_t)DisplayItemType::TYPE_OPACITY); if (animationData) { wrlm->WrBridge()->SendGetAnimationOpacity( animationData->GetAnimationInfo().GetCompositorAnimationsId(), &value, &hadAnimatedOpacity); } } if (hadAnimatedOpacity) { cssValue = new nsROCSSPrimitiveValue; cssValue->SetNumber(value); } } else if (aProperty.EqualsLiteral("transform")) { MaybeTransform transform; Layer* layer = FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_TRANSFORM); if (layer) { ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder(); if (forwarder && forwarder->HasShadowManager()) { forwarder->GetShadowManager()-> SendGetAnimationTransform(layer->GetCompositorAnimationsId(), &transform); } } else if (WebRenderLayerManager* wrlm = widgetLayerManager->AsWebRenderLayerManager()) { RefPtr animationData = GetWebRenderUserData(frame, (uint32_t)DisplayItemType::TYPE_TRANSFORM); if (animationData) { wrlm->WrBridge()->SendGetAnimationTransform( animationData->GetAnimationInfo().GetCompositorAnimationsId(), &transform); } } if (transform.type() == MaybeTransform::TMatrix4x4) { Matrix4x4 matrix = transform.get_Matrix4x4(); cssValue = nsComputedDOMStyle::MatrixToCSSValue(matrix); } } } if (cssValue) { nsString text; ErrorResult rv; cssValue->GetCssText(text, rv); aResult.Assign(text); return rv.StealNSResult(); } aResult.Truncate(); return NS_OK; } namespace { class HandlingUserInputHelper final : public nsIJSRAIIHelper { public: explicit HandlingUserInputHelper(bool aHandlingUserInput); NS_DECL_ISUPPORTS NS_DECL_NSIJSRAIIHELPER private: ~HandlingUserInputHelper(); bool mHandlingUserInput; bool mDestructCalled; }; NS_IMPL_ISUPPORTS(HandlingUserInputHelper, nsIJSRAIIHelper) HandlingUserInputHelper::HandlingUserInputHelper(bool aHandlingUserInput) : mHandlingUserInput(aHandlingUserInput), mDestructCalled(false) { if (aHandlingUserInput) { EventStateManager::StartHandlingUserInput(eVoidEvent); } } HandlingUserInputHelper::~HandlingUserInputHelper() { // We assert, but just in case, make sure we notify the ESM. MOZ_ASSERT(mDestructCalled); if (!mDestructCalled) { Destruct(); } } NS_IMETHODIMP HandlingUserInputHelper::Destruct() { if (NS_WARN_IF(mDestructCalled)) { return NS_ERROR_FAILURE; } mDestructCalled = true; if (mHandlingUserInput) { EventStateManager::StopHandlingUserInput(eVoidEvent); } return NS_OK; } } // unnamed namespace NS_IMETHODIMP nsDOMWindowUtils::SetHandlingUserInput(bool aHandlingUserInput, nsIJSRAIIHelper** aHelper) { RefPtr helper( new HandlingUserInputHelper(aHandlingUserInput)); helper.forget(aHelper); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetContentAPZTestData(JSContext* aContext, JS::MutableHandleValue aOutContentTestData) { if (nsIWidget* widget = GetWidget()) { RefPtr lm = widget->GetLayerManager(); if (!lm) { return NS_OK; } if (ClientLayerManager* clm = lm->AsClientLayerManager()) { if (!clm->GetAPZTestData().ToJS(aOutContentTestData, aContext)) { return NS_ERROR_FAILURE; } } else if (WebRenderLayerManager* wrlm = lm->AsWebRenderLayerManager()) { if (!wrlm->GetAPZTestData().ToJS(aOutContentTestData, aContext)) { return NS_ERROR_FAILURE; } } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetCompositorAPZTestData(JSContext* aContext, JS::MutableHandleValue aOutCompositorTestData) { if (nsIWidget* widget = GetWidget()) { RefPtr lm = widget->GetLayerManager(); if (!lm) { return NS_OK; } APZTestData compositorSideData; if (ClientLayerManager* clm = lm->AsClientLayerManager()) { clm->GetCompositorSideAPZTestData(&compositorSideData); } else if (WebRenderLayerManager* wrlm = lm->AsWebRenderLayerManager()) { if (!wrlm->WrBridge()) { return NS_ERROR_UNEXPECTED; } if (!wrlm->WrBridge()->SendGetAPZTestData(&compositorSideData)) { return NS_ERROR_FAILURE; } } if (!compositorSideData.ToJS(aOutCompositorTestData, aContext)) { return NS_ERROR_FAILURE; } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::PostRestyleSelfEvent(nsIDOMElement* aElement) { nsCOMPtr element = do_QueryInterface(aElement); if (!element) { return NS_ERROR_INVALID_ARG; } nsLayoutUtils::PostRestyleEvent(element, eRestyle_Self, nsChangeHint(0)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetMediaSuspend(uint32_t* aSuspend) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); *aSuspend = window->GetMediaSuspend(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetMediaSuspend(uint32_t aSuspend) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); window->SetMediaSuspend(aSuspend); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetAudioMuted(bool* aMuted) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); *aMuted = window->GetAudioMuted(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetAudioMuted(bool aMuted) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); window->SetAudioMuted(aMuted); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetAudioVolume(float* aVolume) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); *aVolume = window->GetAudioVolume(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetAudioVolume(float aVolume) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); return window->SetAudioVolume(aVolume); } NS_IMETHODIMP nsDOMWindowUtils::SetChromeMargin(int32_t aTop, int32_t aRight, int32_t aBottom, int32_t aLeft) { nsCOMPtr window = do_QueryReferent(mWindow); if (window) { nsCOMPtr baseWindow = do_QueryInterface(window->GetDocShell()); if (baseWindow) { nsCOMPtr widget; baseWindow->GetMainWidget(getter_AddRefs(widget)); if (widget) { LayoutDeviceIntMargin margins(aTop, aRight, aBottom, aLeft); return widget->SetNonClientMargins(margins); } } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFrameUniformityTestData(JSContext* aContext, JS::MutableHandleValue aOutFrameUniformity) { nsIWidget* widget = GetWidget(); if (!widget) { return NS_ERROR_NOT_AVAILABLE; } RefPtr manager = widget->GetLayerManager(); if (!manager) { return NS_ERROR_NOT_AVAILABLE; } FrameUniformityData outData; manager->GetFrameUniformity(&outData); outData.ToJS(aOutFrameUniformity, aContext); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::XpconnectArgument(nsIDOMWindowUtils* aThis) { // Do nothing. return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::AskPermission(nsIContentPermissionRequest* aRequest) { nsCOMPtr window = do_QueryReferent(mWindow); return nsContentPermissionUtils::AskPermission(aRequest, window->GetCurrentInnerWindow()); } NS_IMETHODIMP nsDOMWindowUtils::GetRestyleGeneration(uint64_t* aResult) { nsPresContext* presContext = GetPresContext(); if (!presContext) { return NS_ERROR_NOT_AVAILABLE; } *aResult = presContext->GetRestyleGeneration(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFramesConstructed(uint64_t* aResult) { nsPresContext* presContext = GetPresContext(); if (!presContext) { return NS_ERROR_NOT_AVAILABLE; } *aResult = presContext->FramesConstructedCount(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetFramesReflowed(uint64_t* aResult) { nsPresContext* presContext = GetPresContext(); if (!presContext) { return NS_ERROR_NOT_AVAILABLE; } *aResult = presContext->FramesReflowedCount(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SetServiceWorkersTestingEnabled(bool aEnabled) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); window->SetServiceWorkersTestingEnabled(aEnabled); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetServiceWorkersTestingEnabled(bool *aEnabled) { nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); *aEnabled = window->GetServiceWorkersTestingEnabled(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::EnterChaosMode() { ChaosMode::enterChaosMode(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::LeaveChaosMode() { ChaosMode::leaveChaosMode(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::TriggerDeviceReset() { ContentChild* cc = ContentChild::GetSingleton(); if (cc) { cc->SendDeviceReset(); return NS_OK; } GPUProcessManager* pm = GPUProcessManager::Get(); if (pm) { pm->SimulateDeviceReset(); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ForceUseCounterFlush(nsIDOMNode *aNode) { NS_ENSURE_ARG_POINTER(aNode); if (nsCOMPtr doc = do_QueryInterface(aNode)) { mozilla::css::ImageLoader* loader = doc->StyleImageLoader(); loader->FlushUseCounters(); // Flush the document and any external documents that it depends on. const auto reportKind = nsDocument::UseCounterReportKind::eIncludeExternalResources; static_cast(doc.get())->ReportUseCounters(reportKind); return NS_OK; } if (nsCOMPtr content = do_QueryInterface(aNode)) { if (HTMLImageElement* img = HTMLImageElement::FromNode(content)) { img->FlushUseCounters(); return NS_OK; } } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::HasRuleProcessorUsedByMultipleStyleSets(uint32_t aSheetType, bool* aRetVal) { nsIPresShell* presShell = GetPresShell(); if (!presShell) { return NS_ERROR_FAILURE; } return presShell->HasRuleProcessorUsedByMultipleStyleSets(aSheetType, aRetVal); } NS_IMETHODIMP nsDOMWindowUtils::RespectDisplayPortSuppression(bool aEnabled) { nsCOMPtr shell(GetPresShell()); APZCCallbackHelper::RespectDisplayPortSuppression(aEnabled, shell); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ForceReflowInterrupt() { nsPresContext* pc = GetPresContext(); if (!pc) { return NS_ERROR_NOT_AVAILABLE; } pc->SetPendingInterruptFromTest(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::TerminateGPUProcess() { GPUProcessManager* pm = GPUProcessManager::Get(); if (pm) { pm->KillProcess(); } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetGpuProcessPid(int32_t* aPid) { GPUProcessManager* pm = GPUProcessManager::Get(); if (pm) { *aPid = pm->GPUProcessPid(); } else { *aPid = -1; } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::IsTimeoutTracking(uint32_t aTimeoutId, bool* aResult) { NS_ENSURE_ARG_POINTER(aResult); *aResult = false; nsCOMPtr window = do_QueryReferent(mWindow); NS_ENSURE_STATE(window); nsCOMPtr innerWindow = window->GetCurrentInnerWindow(); NS_ENSURE_STATE(innerWindow); *aResult = innerWindow->TimeoutManager().IsTimeoutTracking(aTimeoutId); return NS_OK; } struct StateTableEntry { const char* mStateString; EventStates mState; }; static constexpr StateTableEntry kManuallyManagedStates[] = { { "-moz-autofill", NS_EVENT_STATE_AUTOFILL }, { "-moz-autofill-preview", NS_EVENT_STATE_AUTOFILL_PREVIEW }, { nullptr, EventStates() }, }; static_assert(!kManuallyManagedStates[ArrayLength(kManuallyManagedStates) - 1] .mStateString, "last kManuallyManagedStates entry must be a sentinel with " "mStateString == nullptr"); static EventStates GetEventStateForString(const nsAString& aStateString) { for (const StateTableEntry* entry = kManuallyManagedStates; entry->mStateString; ++entry) { if (aStateString.EqualsASCII(entry->mStateString)) { return entry->mState; } } return EventStates(); } NS_IMETHODIMP nsDOMWindowUtils::AddManuallyManagedState(nsIDOMElement* aElement, const nsAString& aStateString) { nsCOMPtr element = do_QueryInterface(aElement); if (!element) { return NS_ERROR_INVALID_ARG; } EventStates state = GetEventStateForString(aStateString); if (state.IsEmpty()) { return NS_ERROR_INVALID_ARG; } element->AddManuallyManagedStates(state); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::RemoveManuallyManagedState(nsIDOMElement* aElement, const nsAString& aStateString) { nsCOMPtr element = do_QueryInterface(aElement); if (!element) { return NS_ERROR_INVALID_ARG; } EventStates state = GetEventStateForString(aStateString); if (state.IsEmpty()) { return NS_ERROR_INVALID_ARG; } element->RemoveManuallyManagedStates(state); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetStorageUsage(nsIDOMStorage* aStorage, int64_t* aRetval) { RefPtr storage = static_cast(aStorage); if (!storage) { return NS_ERROR_UNEXPECTED; } *aRetval = storage->GetOriginQuotaUsage(); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetDirectionFromText(const nsAString& aString, int32_t* aRetval) { Directionality dir = ::GetDirectionFromText(aString.BeginReading(), aString.Length(), nullptr); switch (dir) { case eDir_NotSet: *aRetval = nsIDOMWindowUtils::DIRECTION_NOT_SET; break; case eDir_RTL: *aRetval = nsIDOMWindowUtils::DIRECTION_RTL; break; case eDir_LTR: *aRetval = nsIDOMWindowUtils::DIRECTION_LTR; break; case eDir_Auto: MOZ_ASSERT_UNREACHABLE("GetDirectionFromText should never return this value"); return NS_ERROR_FAILURE; } return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::EnsureDirtyRootFrame() { nsIDocument* doc = GetDocument(); nsIPresShell* presShell = doc ? doc->GetShell() : nullptr; if (!presShell) { return NS_ERROR_FAILURE; } nsIFrame* frame = presShell->GetRootFrame(); if (!frame) { return NS_ERROR_FAILURE; } presShell->FrameNeedsReflow(frame, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::GetIsStyledByServo(bool* aStyledByServo) { *aStyledByServo = true; return NS_OK; } NS_INTERFACE_MAP_BEGIN(nsTranslationNodeList) NS_INTERFACE_MAP_ENTRY(nsISupports) NS_INTERFACE_MAP_ENTRY(nsITranslationNodeList) NS_INTERFACE_MAP_END NS_IMPL_ADDREF(nsTranslationNodeList) NS_IMPL_RELEASE(nsTranslationNodeList) NS_IMETHODIMP nsTranslationNodeList::Item(uint32_t aIndex, nsIDOMNode** aRetVal) { NS_ENSURE_ARG_POINTER(aRetVal); NS_IF_ADDREF(*aRetVal = mNodes.SafeElementAt(aIndex)); return NS_OK; } NS_IMETHODIMP nsTranslationNodeList::IsTranslationRootAtIndex(uint32_t aIndex, bool* aRetVal) { NS_ENSURE_ARG_POINTER(aRetVal); if (aIndex >= mLength) { *aRetVal = false; return NS_OK; } *aRetVal = mNodeIsRoot.ElementAt(aIndex); return NS_OK; } NS_IMETHODIMP nsTranslationNodeList::GetLength(uint32_t* aRetVal) { NS_ENSURE_ARG_POINTER(aRetVal); *aRetVal = mLength; return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::WrCapture() { if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) { wrbc->Capture(); } return NS_OK; }