Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-07 21:43:24 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2207b79606
gecko-dev/dom/base/nsDOMWindowUtils.cpp
Jeremy Chen 419e2e9b26 Bug 1403077 - add two test-only helper functions to access the stylo blocklist. r=heycam 
In the current blocklist implementation, we read the stylo blocklist from the user
preferences very early and only once, even earlier than the test preferences
updating happens.

So, to be able to test the functionality of the stylo blocklist, we add these two
nsIDOMWindowUtils APIs to be able to add/remove a mock domain to the existing
blocklist.

MozReview-Commit-ID: K48ejLBcNbn

--HG--
extra : rebase_source : 354fe9871231f2a94f09bd2612c9d21ced4143e8
2017-10-09 12:07:04 +08:00

4561 lines
132 KiB
C++
Raw Blame History

/* -*- 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 "nsDOMClassInfoID.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 <algorithm>
#if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK)
#include <gdk/gdk.h>
#include <gdk/gdkx.h>
#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/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 "nsIDOMStyleSheet.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/APZCTreeManager.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<OldWindowSize>
{
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<OldWindowSize> sList;
nsWeakPtr mWindowRef;
nsSize mSize;
};
namespace {
class NativeInputRunnable final : public PrioritizableRunnable
{
explicit NativeInputRunnable(already_AddRefed<nsIRunnable>&& aEvent);
~NativeInputRunnable() {}
public:
static already_AddRefed<nsIRunnable> Create(already_AddRefed<nsIRunnable>&& aEvent);
};
NativeInputRunnable::NativeInputRunnable(already_AddRefed<nsIRunnable>&& aEvent)
: PrioritizableRunnable(Move(aEvent), nsIRunnablePriority::PRIORITY_INPUT)
{
}
/* static */ already_AddRefed<nsIRunnable>
NativeInputRunnable::Create(already_AddRefed<nsIRunnable>&& aEvent)
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIRunnable> event(new NativeInputRunnable(Move(aEvent)));
return event.forget();
}
} // unnamed namespace
LinkedList<OldWindowSize> 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(nsGlobalWindow *aWindow)
{
nsCOMPtr<nsISupports> supports = do_QueryObject(aWindow);
mWindow = do_GetWeakReference(supports);
NS_ASSERTION(aWindow->IsOuterWindow(), "How did that happen?");
}
nsDOMWindowUtils::~nsDOMWindowUtils()
{
OldWindowSize::GetAndRemove(mWindow);
}
nsIPresShell*
nsDOMWindowUtils::GetPresShell()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
if (!window)
return nullptr;
nsIDocShell *docShell = window->GetDocShell();
if (!docShell)
return nullptr;
return docShell->GetPresShell();
}
nsPresContext*
nsDOMWindowUtils::GetPresContext()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
if (!window)
return nullptr;
nsIDocShell *docShell = window->GetDocShell();
if (!docShell)
return nullptr;
RefPtr<nsPresContext> presContext;
docShell->GetPresContext(getter_AddRefs(presContext));
return presContext;
}
nsIDocument*
nsDOMWindowUtils::GetDocument()
{
nsCOMPtr<nsPIDOMWindowOuter> 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::GetDocumentMetadata(const nsAString& aName,
nsAString& aValue)
{
nsIDocument* doc = GetDocument();
if (doc) {
RefPtr<nsAtom> 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()) {
presShell->FlushPendingNotifications(FlushType::Display);
RefPtr<nsViewManager> 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<nsIContent> 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<DisplayPortPropertyData*>(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<DisplayPortPropertyData>);
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);
}
}
nsIFrame* rootFrame = presShell->FrameManager()->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<nsIWidget> 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<nsIContent> 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<nsIContent> 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<nsIPresShell> presShell = GetPresShell();
return nsContentUtils::SendMouseEvent(presShell, aType, aX, aY, aButton,
aButtons, aClickCount, aModifiers, aIgnoreRootScrollFrame, aPressure,
aInputSourceArg, aPointerId, aToWindow, aPreventDefault,
aIsDOMEventSynthesized, aIsWidgetEventSynthesized);
}
NS_IMETHODIMP
nsDOMWindowUtils::SendPointerEventCommon(const nsAString& aType,
float aX,
float aY,
int32_t aButton,
int32_t aClickCount,
int32_t aModifiers,
bool aIgnoreRootScrollFrame,
float aPressure,
unsigned short aInputSourceArg,
int32_t aPointerId,
int32_t aWidth,
int32_t aHeight,
int32_t aTiltX,
int32_t aTiltY,
bool aIsPrimary,
bool aIsSynthesized,
uint8_t aOptionalArgCount,
bool aToWindow,
bool* aPreventDefault)
{
// get the widget to send the event to
nsPoint offset;
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
if (!widget) {
return NS_ERROR_FAILURE;
}
EventMessage msg;
if (aType.EqualsLiteral("pointerdown")) {
msg = ePointerDown;
} else if (aType.EqualsLiteral("pointerup")) {
msg = ePointerUp;
} else if (aType.EqualsLiteral("pointermove")) {
msg = ePointerMove;
} else if (aType.EqualsLiteral("pointerover")) {
msg = ePointerOver;
} else if (aType.EqualsLiteral("pointerout")) {
msg = ePointerOut;
} else {
return NS_ERROR_FAILURE;
}
if (aInputSourceArg == nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN) {
aInputSourceArg = nsIDOMMouseEvent::MOZ_SOURCE_MOUSE;
}
WidgetPointerEvent event(true, msg, widget);
event.mModifiers = nsContentUtils::GetWidgetModifiers(aModifiers);
event.button = aButton;
event.buttons = nsContentUtils::GetButtonsFlagForButton(aButton);
event.pressure = aPressure;
event.inputSource = aInputSourceArg;
event.pointerId = aPointerId;
event.mWidth = aWidth;
event.mHeight = aHeight;
event.tiltX = aTiltX;
event.tiltY = aTiltY;
event.mIsPrimary =
(nsIDOMMouseEvent::MOZ_SOURCE_MOUSE == aInputSourceArg) ? true : aIsPrimary;
event.mClickCount = aClickCount;
event.mTime = PR_IntervalNow();
event.mFlags.mIsSynthesizedForTests = aOptionalArgCount >= 10 ? aIsSynthesized : true;
nsPresContext* presContext = GetPresContext();
if (!presContext) {
return NS_ERROR_FAILURE;
}
event.mRefPoint =
nsContentUtils::ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
event.mIgnoreRootScrollFrame = aIgnoreRootScrollFrame;
nsEventStatus status;
if (aToWindow) {
nsCOMPtr<nsIPresShell> presShell;
nsView* view = nsContentUtils::GetViewToDispatchEvent(presContext, getter_AddRefs(presShell));
if (!presShell || !view) {
return NS_ERROR_FAILURE;
}
status = nsEventStatus_eIgnore;
return presShell->HandleEvent(view->GetFrame(), &event, false, &status);
}
nsresult rv = widget->DispatchEvent(&event, status);
if (aPreventDefault) {
*aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
}
return rv;
}
NS_IMETHODIMP
nsDOMWindowUtils::SendPointerEvent(const nsAString& aType,
float aX,
float aY,
int32_t aButton,
int32_t aClickCount,
int32_t aModifiers,
bool aIgnoreRootScrollFrame,
float aPressure,
unsigned short aInputSourceArg,
int32_t aPointerId,
int32_t aWidth,
int32_t aHeight,
int32_t aTiltX,
int32_t aTiltY,
bool aIsPrimary,
bool aIsSynthesized,
uint8_t aOptionalArgCount,
bool* aPreventDefault)
{
AUTO_PROFILER_LABEL("nsDOMWindowUtils::SendPointerEvent", EVENTS);
return SendPointerEventCommon(aType, aX, aY, aButton, aClickCount,
aModifiers, aIgnoreRootScrollFrame,
aPressure, aInputSourceArg, aPointerId,
aWidth, aHeight, aTiltX, aTiltY,
aIsPrimary, aIsSynthesized,
aOptionalArgCount, false, aPreventDefault);
}
NS_IMETHODIMP
nsDOMWindowUtils::SendPointerEventToWindow(const nsAString& aType,
float aX,
float aY,
int32_t aButton,
int32_t aClickCount,
int32_t aModifiers,
bool aIgnoreRootScrollFrame,
float aPressure,
unsigned short aInputSourceArg,
int32_t aPointerId,
int32_t aWidth,
int32_t aHeight,
int32_t aTiltX,
int32_t aTiltY,
bool aIsPrimary,
bool aIsSynthesized,
uint8_t aOptionalArgCount)
{
AUTO_PROFILER_LABEL("nsDOMWindowUtils::SendPointerEventToWindow", EVENTS);
return SendPointerEventCommon(aType, aX, aY, aButton, aClickCount,
aModifiers, aIgnoreRootScrollFrame,
aPressure, aInputSourceArg, aPointerId,
aWidth, aHeight, aTiltX, aTiltY,
aIsPrimary, aIsSynthesized,
aOptionalArgCount, true, nullptr);
}
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<nsIWidget> 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<nsIWidget> 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<Touch> t =
new Touch(aIdentifiers[i], pt, radius, aRotationAngles[i], aForces[i]);
event.mTouches.AppendElement(t);
}
nsEventStatus status;
if (aToWindow) {
nsCOMPtr<nsIPresShell> 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::SendKeyEvent(const nsAString& aType,
int32_t aKeyCode,
int32_t aCharCode,
int32_t aModifiers,
uint32_t aAdditionalFlags,
bool* aDefaultActionTaken)
{
// get the widget to send the event to
nsCOMPtr<nsIWidget> widget = GetWidget();
return nsContentUtils::SendKeyEvent(widget, aType, aKeyCode, aCharCode,
aModifiers, aAdditionalFlags,
aDefaultActionTaken);
}
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<nsIWidget> widget = GetWidget();
if (!widget)
return NS_ERROR_FAILURE;
NS_DispatchToMainThread(NativeInputRunnable::Create(
NewRunnableMethod<int32_t,
int32_t,
uint32_t,
nsString,
nsString,
nsIObserver*>("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<nsIWidget> widget = GetWidgetForElement(aElement);
if (!widget)
return NS_ERROR_FAILURE;
NS_DispatchToMainThread(NativeInputRunnable::Create(
NewRunnableMethod<LayoutDeviceIntPoint, int32_t, int32_t, nsIObserver*>(
"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<nsIWidget> widget = GetWidgetForElement(aElement);
if (!widget)
return NS_ERROR_FAILURE;
NS_DispatchToMainThread(NativeInputRunnable::Create(
NewRunnableMethod<LayoutDeviceIntPoint, nsIObserver*>(
"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<nsIWidget> widget = GetWidgetForElement(aElement);
if (!widget) {
return NS_ERROR_FAILURE;
}
NS_DispatchToMainThread(NativeInputRunnable::Create(
NewRunnableMethod<mozilla::LayoutDeviceIntPoint,
uint32_t,
double,
double,
double,
uint32_t,
uint32_t,
nsIObserver*>(
"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<nsIWidget> 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<uint32_t,
nsIWidget::TouchPointerState,
LayoutDeviceIntPoint,
double,
uint32_t,
nsIObserver*>("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<nsIWidget> widget = GetWidget();
if (!widget) {
return NS_ERROR_FAILURE;
}
NS_DispatchToMainThread(NativeInputRunnable::Create(
NewRunnableMethod<LayoutDeviceIntPoint, bool, nsIObserver*>(
"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<nsIWidget> widget = GetWidget();
if (!widget) {
return NS_ERROR_FAILURE;
}
NS_DispatchToMainThread(NativeInputRunnable::Create(
NewRunnableMethod<nsIObserver*>("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<nsIWidget> 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<nsIWidget> 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<nsIWidget> widget = GetWidget();
if (!widget) {
return NS_ERROR_FAILURE;
}
return widget->GetSelectionAsPlaintext(aResult);
}
nsIWidget*
nsDOMWindowUtils::GetWidget(nsPoint* aOffset)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
if (window) {
nsIDocShell *docShell = window->GetDocShell();
if (docShell) {
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
return nsContentUtils::GetWidget(presShell, aOffset);
}
}
return nullptr;
}
nsIWidget*
nsDOMWindowUtils::GetWidgetForElement(nsIDOMElement* aElement)
{
if (!aElement)
return GetWidget();
nsCOMPtr<nsIContent> 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::Focus(nsIDOMElement* aElement)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
if (fm) {
if (aElement)
fm->SetFocus(aElement, 0);
else
fm->ClearFocus(window);
}
return NS_OK;
}
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<nsIWidget> 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<nsIDocument> doc = GetDocument();
NS_ENSURE_STATE(doc);
Element* el =
doc->ElementFromPointHelper(aX, aY, aIgnoreRootScrollFrame, aFlushLayout);
nsCOMPtr<nsIDOMElement> 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<nsIDocument> 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<nsIContent> root = do_QueryInterface(aRoot);
NS_ENSURE_STATE(root);
nsCOMPtr<nsIDocument> doc = GetDocument();
NS_ENSURE_STATE(doc);
if (root->OwnerDoc() != doc) {
return NS_ERROR_DOM_WRONG_DOCUMENT_ERR;
}
nsTHashtable<nsPtrHashKey<nsIContent>> translationNodesHash(500);
RefPtr<nsTranslationNodeList> 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->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<DataSourceSurface>
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<nsIContent> contentCanvas1 = do_QueryInterface(aCanvas1);
nsCOMPtr<nsIContent> contentCanvas2 = do_QueryInterface(aCanvas2);
auto canvas1 = HTMLCanvasElement::FromContentOrNull(contentCanvas1);
auto canvas2 = HTMLCanvasElement::FromContentOrNull(contentCanvas2);
if (!canvas1 || !canvas2) {
return NS_ERROR_FAILURE;
}
RefPtr<DataSourceSurface> img1 = CanvasToDataSourceSurface(canvas1);
RefPtr<DataSourceSurface> img2 = CanvasToDataSourceSurface(canvas2);
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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsIDocShell *docShell = window->GetDocShell();
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
presShell->DisableNonTestMouseEvents(aDisable);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::SuppressEventHandling(bool aSuppress)
{
nsCOMPtr<nsIDocument> 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<nsPIDOMWindowOuter> window = do_QueryReferent(aWindow);
nsCOMPtr<nsIDocument> 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<nsIDocument> 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,
nsIDOMClientRect** aResult)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
nsresult rv;
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
NS_ENSURE_SUCCESS(rv, rv);
RefPtr<DOMRect> 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<nsIDocument> 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::GetRootBounds(nsIDOMClientRect** 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
RefPtr<DOMRect> 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<nsIWidget> 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<nsIWidget> widget = GetWidget();
if (!widget)
return NS_ERROR_FAILURE;
InputContext context = widget->GetInputContext();
*aState = static_cast<uint32_t>(context.mIMEState.mEnabled);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetFocusedInputType(char** aType)
{
NS_ENSURE_ARG_POINTER(aType);
nsCOMPtr<nsIWidget> widget = GetWidget();
if (!widget) {
return NS_ERROR_FAILURE;
}
InputContext context = widget->GetInputContext();
*aType = ToNewCString(context.mHTMLInputType);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetViewId(nsIDOMElement* aElement, nsViewID* aResult)
{
nsCOMPtr<nsIContent> 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<nsPIDOMWindowOuter> 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<nsIContent> content = do_QueryInterface(aTarget);
NS_ENSURE_STATE(content);
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
if (content->OwnerDoc()->GetWindow() != window) {
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
}
nsCOMPtr<nsIDocument> targetDoc = content->GetUncomposedDoc();
NS_ENSURE_STATE(targetDoc);
RefPtr<nsIPresShell> 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsIDocShell *docShell = window->GetDocShell();
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
nsCOMPtr<nsIPresShell> 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<nsIWidget> 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<nsIWidget> 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<nsIWidget> 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<nsIWidget> 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<JS::Value> 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
nsCOMPtr<Element> element = do_QueryInterface(aElement);
NS_ENSURE_STATE(window && element);
nsCOMPtr<nsPIDOMWindowInner> innerWindow = window->GetCurrentInnerWindow();
NS_ENSURE_STATE(window);
nsCOMPtr<nsIDOMCSSStyleDeclaration> decl;
{
ErrorResult rv;
decl = innerWindow->GetComputedStyle(*element, aPseudoElement, rv);
ENSURE_SUCCESS(rv, rv.StealNSResult());
}
static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(true);
nsresult rv = decl->GetPropertyValue(aPropertyName, aResult);
static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(false);
return rv;
}
NS_IMETHODIMP
nsDOMWindowUtils::EnterModalState()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
window->EnterModalState();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::LeaveModalState()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
window->LeaveModalState();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::IsInModalState(bool *retval)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
*retval = nsGlobalWindow::Cast(window)->IsInModalState();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::SetDesktopModeViewport(bool aDesktopMode)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
window->SetDesktopModeViewport(aDesktopMode);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetOuterWindowID(uint64_t *aWindowID)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
NS_ASSERTION(window->IsOuterWindow(), "How did that happen?");
*aWindowID = window->WindowID();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetCurrentInnerWindowID(uint64_t *aWindowID)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_NOT_AVAILABLE);
NS_ASSERTION(window->IsOuterWindow(), "How did that happen?");
nsGlobalWindow* inner =
nsGlobalWindow::Cast(window)->GetCurrentInnerWindowInternal();
if (!inner) {
return NS_ERROR_NOT_AVAILABLE;
}
*aWindowID = inner->WindowID();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::SuspendTimeouts()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsCOMPtr<nsPIDOMWindowInner> inner = window->GetCurrentInnerWindow();
NS_ENSURE_TRUE(inner, NS_ERROR_FAILURE);
inner->Suspend();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::ResumeTimeouts()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsCOMPtr<nsPIDOMWindowInner> inner = window->GetCurrentInnerWindow();
NS_ENSURE_TRUE(inner, NS_ERROR_FAILURE);
inner->Resume();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetLayerManagerType(nsAString& aType)
{
nsCOMPtr<nsIWidget> 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<nsIWidget> 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<nsIWidget> 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::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::GetCurrentPreferredChannelLayout(nsAString& aLayout)
{
CubebUtils::GetPreferredChannelLayout(aLayout);
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<nsIMutableArray> devices =
do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsTArray<RefPtr<AudioDeviceInfo>> collection;
CubebUtils::GetDeviceCollection(collection,
aSide == AUDIO_INPUT
? CubebUtils::Side::Input
: CubebUtils::Side::Output);
for (auto device: collection) {
devices->AppendElement(device, false);
}
devices.forget(aDevices);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::StartFrameTimeRecording(uint32_t *startIndex)
{
NS_ENSURE_ARG_POINTER(startIndex);
nsCOMPtr<nsIWidget> 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<nsIWidget> widget = GetWidget();
if (!widget)
return NS_ERROR_FAILURE;
LayerManager *mgr = widget->GetLayerManager();
if (!mgr)
return NS_ERROR_FAILURE;
nsTArray<float> 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<nsIDocument> 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<LayerTransactionChild> 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<LayerTransactionChild> 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> 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> 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<nsIContent> 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<nsStyleContext> styleContext;
nsIDocument* doc = element->GetComposedDoc();
if (doc && doc->GetShell()) {
styleContext =
nsComputedDOMStyle::GetStyleContext(element, nullptr, doc->GetShell());
}
*aResult = v1.ComputeDistance(property, v2, styleContext);
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,
nsAString& aResult)
{
nsCOMPtr<Element> 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;
}
nsIPresShell* shell = GetPresShell();
if (!shell) {
return NS_ERROR_FAILURE;
}
RefPtr<nsAtom> pseudo = nsCSSPseudoElements::GetPseudoAtom(aPseudoElement);
RefPtr<nsStyleContext> styleContext =
nsComputedDOMStyle::GetUnanimatedStyleContextNoFlush(element,
pseudo, shell);
if (styleContext->IsServo()) {
RefPtr<RawServoAnimationValue> value =
Servo_ComputedValues_ExtractAnimationValue(styleContext->AsServo(),
propertyID).Consume();
if (!value) {
return NS_ERROR_FAILURE;
}
Servo_AnimationValue_Serialize(value, propertyID, &aResult);
return NS_OK;
}
StyleAnimationValue computedValue;
if (!StyleAnimationValue::ExtractComputedValue(propertyID,
styleContext->AsGecko(),
computedValue)) {
return NS_ERROR_FAILURE;
}
// Note: ExtractComputedValue can return 'unset', 'initial', or 'inherit' in
// its "computedValue" outparam, even though these technically aren't valid
// computed values. (It has this behavior for discretely-animatable
// properties, e.g. 'align-content', when these keywords are explicitly
// specified or when there is no specified value.) But we need to return a
// valid computed value -- these keywords won't do. So we fall back to
// nsComputedDOMStyle in this case.
if (computedValue.GetUnit() == StyleAnimationValue::eUnit_DiscreteCSSValue &&
(computedValue.GetCSSValueValue()->GetUnit() == eCSSUnit_Unset ||
computedValue.GetCSSValueValue()->GetUnit() == eCSSUnit_Initial ||
computedValue.GetCSSValueValue()->GetUnit() == eCSSUnit_Inherit)) {
RefPtr<nsComputedDOMStyle> computedStyle =
NS_NewComputedDOMStyle(
element, aPseudoElement, shell,
nsComputedDOMStyle::StyleType::eAll,
nsComputedDOMStyle::AnimationFlag::eWithoutAnimation);
computedStyle->GetPropertyValue(propertyID, aResult);
return NS_OK;
}
DebugOnly<bool> uncomputeResult =
StyleAnimationValue::UncomputeValue(propertyID,
Move(computedValue), aResult);
MOZ_ASSERT(uncomputeResult,
"Unable to get specified value from computed value");
return NS_OK;
}
nsresult
nsDOMWindowUtils::RenderDocument(const nsRect& aRect,
uint32_t aFlags,
nscolor aBackgroundColor,
gfxContext* aThebesContext)
{
nsCOMPtr<nsIDocument> doc = GetDocument();
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
// Get Primary Shell
nsCOMPtr<nsIPresShell> 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<nsIWidget> widget = GetWidget();
if (!widget)
return NS_ERROR_FAILURE;
*aDPI = widget->GetDPI();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetContainerElement(nsIDOMElement** aResult)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
nsCOMPtr<nsIDOMElement> 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<nsIContent> 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::IsPartOfOpaqueLayer(nsIDOMElement* aElement, bool* aResult)
{
if (!aElement) {
return NS_ERROR_INVALID_ARG;
}
nsresult rv;
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsIFrame* frame = content->GetPrimaryFrame();
if (!frame) {
return NS_ERROR_FAILURE;
}
ColorLayer* colorLayer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame<ColorLayer>(frame);
if (colorLayer) {
auto color = colorLayer->GetColor();
*aResult = color.a == 1.0f;
return NS_OK;
}
PaintedLayer* paintedLayer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame<PaintedLayer>(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<nsPtrHashKey<PaintedLayer>> layers;
nsresult rv;
for (uint32_t i = 0; i < aCount; i++) {
nsCOMPtr<nsIContent> 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<PaintedLayer>(frame);
if (!layer) {
return NS_ERROR_FAILURE;
}
layers.PutEntry(layer);
}
*aResult = layers.Count();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::EnableDialogs()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsGlobalWindow::Cast(window)->EnableDialogs();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::DisableDialogs()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsGlobalWindow::Cast(window)->DisableDialogs();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::AreDialogsEnabled(bool* aResult)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
*aResult = nsGlobalWindow::Cast(window)->AreDialogsEnabled();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetFileId(JS::Handle<JS::Value> aFile, JSContext* aCx,
int64_t* _retval)
{
if (aFile.isPrimitive()) {
*_retval = -1;
return NS_OK;
}
JS::Rooted<JSObject*> 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<JSObject*> 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<JS::Value> aOptions,
int32_t* aRefCnt, int32_t* aDBRefCnt,
int32_t* aSliceRefCnt, JSContext* aCx,
bool* aResult)
{
nsCOMPtr<nsPIDOMWindowOuter> 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<JS::Value> optionsVal(aCx, aOptions);
if (!options.Init(aCx, optionsVal)) {
return NS_ERROR_TYPE_ERR;
}
quota::PersistenceType persistenceType =
quota::PersistenceTypeFromStorage(options.mStorage);
RefPtr<IndexedDatabaseManager> 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<IndexedDatabaseManager> 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
nsIDocShell *docShell = window->GetDocShell();
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
*aPaintingSuppressed = presShell->IsPaintingSuppressed();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetPlugins(JSContext* cx, JS::MutableHandle<JS::Value> aPlugins)
{
nsCOMPtr<nsIDocument> doc = GetDocument();
NS_ENSURE_STATE(doc);
nsTArray<nsIObjectLoadingContent*> plugins;
doc->GetPlugins(plugins);
JS::Rooted<JSObject*> 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<nsIDocument> doc = GetDocument();
NS_ENSURE_STATE(doc);
doc->RemoteFrameFullscreenChanged(aFrameElement);
return NS_OK;
}
nsresult
nsDOMWindowUtils::RemoteFrameFullscreenReverted()
{
nsCOMPtr<nsIDocument> 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<nsIDocument> 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<nsIDocument> 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->FrameManager()->GetRootFrame();
if (!rootFrame) {
return NS_ERROR_UNEXPECTED;
}
// Get the target frame at the client coordinates passed to us
nsPoint offset;
nsCOMPtr<nsIWidget> 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<nsFrame*>(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<nsIDocument> 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<nsIURI> 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<nsIDocument> doc = GetDocument();
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
StyleSheet* sheet = nullptr;
auto preloadedSheet = static_cast<PreloadedStyleSheet*>(aSheet);
nsresult rv = preloadedSheet->GetSheet(doc->GetStyleBackendType(), &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<nsIDocument> 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<nsIURI> 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 = 0;
return NS_OK;
}
*aMillisSinceLastUserInput = (TimeStamp::Now() - lastInput).ToMilliseconds();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::AllowScriptsToClose()
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
nsGlobalWindow::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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
nsCOMPtr<nsIWidget> 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<nsIDocShellTreeOwner> parentTreeOwner;
docShell->GetTreeOwner(getter_AddRefs(parentTreeOwner));
nsCOMPtr<nsIBaseWindow> 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<nsINode> n = do_QueryInterface(aNode);
nsINode* node = n;
while (node) {
if (node->IsNodeOfType(nsINode::eHTML_FORM_CONTROL)) {
nsCOMPtr<nsIFormControl> 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;
aTarget->DispatchEvent(aEvent, aRetVal);
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> element = do_QueryInterface(aElement);
if (!element) {
return NS_ERROR_INVALID_ARG;
}
RefPtr<nsROCSSPrimitiveValue> 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()) {
if (aProperty.EqualsLiteral("opacity")) {
Layer* layer =
FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_OPACITY);
if (layer) {
float value = 0;
bool hadAnimatedOpacity = false;
ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
if (forwarder && forwarder->HasShadowManager()) {
forwarder->GetShadowManager()->
SendGetAnimationOpacity(layer->GetCompositorAnimationsId(),
&value,
&hadAnimatedOpacity);
} else if (WebRenderLayerManager* wrlm = layer->Manager()->AsWebRenderLayerManager()) {
wrlm->WrBridge()->SendGetAnimationOpacity(
layer->GetCompositorAnimationsId(),
&value,
&hadAnimatedOpacity);
}
if (hadAnimatedOpacity) {
cssValue = new nsROCSSPrimitiveValue;
cssValue->SetNumber(value);
}
}
} else if (aProperty.EqualsLiteral("transform")) {
Layer* layer =
FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_TRANSFORM);
if (layer) {
MaybeTransform transform;
ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
if (forwarder && forwarder->HasShadowManager()) {
forwarder->GetShadowManager()->
SendGetAnimationTransform(layer->GetCompositorAnimationsId(), &transform);
} else if (WebRenderLayerManager* wrlm = layer->Manager()->AsWebRenderLayerManager()) {
wrlm->WrBridge()->SendGetAnimationTransform(
layer->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();
}
}
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();
}
return NS_OK;
}
} // unnamed namespace
NS_IMETHODIMP
nsDOMWindowUtils::SetHandlingUserInput(bool aHandlingUserInput,
nsIJSRAIIHelper** aHelper)
{
RefPtr<HandlingUserInputHelper> helper(
new HandlingUserInputHelper(aHandlingUserInput));
helper.forget(aHelper);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetContentAPZTestData(JSContext* aContext,
JS::MutableHandleValue aOutContentTestData)
{
if (nsIWidget* widget = GetWidget()) {
RefPtr<LayerManager> 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<LayerManager> 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> 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
*aSuspend = window->GetMediaSuspend();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::SetMediaSuspend(uint32_t aSuspend)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
window->SetMediaSuspend(aSuspend);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetAudioMuted(bool* aMuted)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
*aMuted = window->GetAudioMuted();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::SetAudioMuted(bool aMuted)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
window->SetAudioMuted(aMuted);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetAudioVolume(float* aVolume)
{
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
*aVolume = window->GetAudioVolume();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::SetAudioVolume(float aVolume)
{
nsCOMPtr<nsPIDOMWindowOuter> 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
if (window) {
nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(window->GetDocShell());
if (baseWindow) {
nsCOMPtr<nsIWidget> 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<LayerManager> 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<nsPIDOMWindowOuter> 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
window->SetServiceWorkersTestingEnabled(aEnabled);
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::GetServiceWorkersTestingEnabled(bool *aEnabled)
{
nsCOMPtr<nsPIDOMWindowOuter> 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<nsIDocument> 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<nsDocument*>(doc.get())->ReportUseCounters(reportKind);
return NS_OK;
}
if (nsCOMPtr<nsIContent> content = do_QueryInterface(aNode)) {
if (HTMLImageElement* img = HTMLImageElement::FromContent(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<nsIPresShell> 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<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
NS_ENSURE_STATE(window);
nsCOMPtr<nsPIDOMWindowInner> 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> 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> 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> storage = static_cast<Storage*>(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)
{
nsIDocument* doc = GetDocument();
*aStyledByServo = doc && doc->IsStyledByServo();
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::AddToStyloBlocklist(const nsACString& aBlockedDomain)
{
#ifdef MOZ_STYLO
nsLayoutUtils::AddToStyloBlocklist(aBlockedDomain);
#endif
return NS_OK;
}
NS_IMETHODIMP
nsDOMWindowUtils::RemoveFromStyloBlocklist(const nsACString& aBlockedDomain)
{
#ifdef MOZ_STYLO
nsLayoutUtils::RemoveFromStyloBlocklist(aBlockedDomain);
#endif
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;
}
Reference in New Issue View Git Blame Copy Permalink