2015-05-03 22:32:37 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2012-05-21 15:12:37 +04:00
|
|
|
/* 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/. */
|
2004-06-20 20:42:13 +04:00
|
|
|
|
2014-02-12 08:41:57 +04:00
|
|
|
#include "nsDOMWindowUtils.h"
|
|
|
|
|
2016-03-22 21:08:38 +03:00
|
|
|
#include "mozilla/layers/CompositorBridgeChild.h"
|
2013-11-27 19:19:34 +04:00
|
|
|
#include "mozilla/layers/LayerTransactionChild.h"
|
2004-08-01 03:15:21 +04:00
|
|
|
#include "nsPresContext.h"
|
2012-07-27 18:03:27 +04:00
|
|
|
#include "nsError.h"
|
2012-08-04 11:44:00 +04:00
|
|
|
#include "nsIDOMEvent.h"
|
2010-03-19 08:02:53 +03:00
|
|
|
#include "nsQueryContentEventResult.h"
|
2004-06-20 20:42:13 +04:00
|
|
|
#include "nsGlobalWindow.h"
|
2004-11-18 23:50:16 +03:00
|
|
|
#include "nsIDocument.h"
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 22:00:39 +04:00
|
|
|
#include "nsFocusManager.h"
|
2011-03-16 02:20:19 +03:00
|
|
|
#include "nsFrameManager.h"
|
2011-04-12 10:18:43 +04:00
|
|
|
#include "nsRefreshDriver.h"
|
2016-12-22 22:05:54 +03:00
|
|
|
#include "mozilla/dom/BindingDeclarations.h"
|
2015-05-19 17:36:37 +03:00
|
|
|
#include "mozilla/dom/BlobBinding.h"
|
2013-04-05 12:49:00 +04:00
|
|
|
#include "mozilla/dom/Touch.h"
|
2015-04-21 04:22:09 +03:00
|
|
|
#include "mozilla/PendingAnimationTracker.h"
|
2013-08-15 22:17:48 +04:00
|
|
|
#include "nsIObjectLoadingContent.h"
|
2012-09-11 01:02:23 +04:00
|
|
|
#include "nsFrame.h"
|
2013-08-15 22:17:48 +04:00
|
|
|
#include "mozilla/layers/ShadowLayers.h"
|
2015-06-19 15:25:41 +03:00
|
|
|
#include "mozilla/layers/APZCCallbackHelper.h"
|
2014-05-10 01:16:03 +04:00
|
|
|
#include "ClientLayerManager.h"
|
2015-04-15 19:47:03 +03:00
|
|
|
#include "nsQueryObject.h"
|
2016-07-26 01:50:14 +03:00
|
|
|
#include "CubebUtils.h"
|
2004-06-20 20:42:13 +04:00
|
|
|
|
2009-09-03 07:57:46 +04:00
|
|
|
#include "nsIScrollableFrame.h"
|
2009-03-30 16:19:06 +04:00
|
|
|
|
2005-10-22 02:30:36 +04:00
|
|
|
#include "nsContentUtils.h"
|
|
|
|
|
|
|
|
#include "nsIFrame.h"
|
2007-02-27 00:14:19 +03:00
|
|
|
#include "nsIWidget.h"
|
2012-03-22 18:42:42 +04:00
|
|
|
#include "nsCharsetSource.h"
|
2007-11-07 00:47:35 +03:00
|
|
|
#include "nsJSEnvironment.h"
|
2011-12-17 01:11:08 +04:00
|
|
|
#include "nsJSUtils.h"
|
2005-10-22 02:30:36 +04:00
|
|
|
|
2015-06-04 20:44:55 +03:00
|
|
|
#include "mozilla/ChaosMode.h"
|
2014-04-01 08:09:23 +04:00
|
|
|
#include "mozilla/EventStateManager.h"
|
2013-09-25 15:21:20 +04:00
|
|
|
#include "mozilla/MiscEvents.h"
|
2013-09-25 15:21:18 +04:00
|
|
|
#include "mozilla/MouseEvents.h"
|
2013-09-25 15:21:19 +04:00
|
|
|
#include "mozilla/TextEvents.h"
|
2015-01-28 09:27:31 +03:00
|
|
|
#include "mozilla/TextEventDispatcher.h"
|
2013-09-25 15:21:16 +04:00
|
|
|
#include "mozilla/TouchEvents.h"
|
|
|
|
|
2013-01-05 07:12:24 +04:00
|
|
|
#include "nsViewManager.h"
|
2008-08-28 01:24:03 +04:00
|
|
|
|
2010-02-24 22:04:32 +03:00
|
|
|
#include "nsLayoutUtils.h"
|
2010-04-03 05:58:25 +04:00
|
|
|
#include "nsComputedDOMStyle.h"
|
2010-08-28 03:15:07 +04:00
|
|
|
#include "nsIPresShell.h"
|
2010-10-24 03:31:55 +04:00
|
|
|
#include "nsCSSProps.h"
|
2012-03-28 19:53:56 +04:00
|
|
|
#include "nsTArrayHelpers.h"
|
2012-05-05 17:28:06 +04:00
|
|
|
#include "nsIDocShell.h"
|
|
|
|
#include "nsIContentViewer.h"
|
2014-06-24 10:29:54 +04:00
|
|
|
#include "mozilla/StyleAnimationValue.h"
|
2014-10-08 20:15:23 +04:00
|
|
|
#include "mozilla/dom/File.h"
|
2015-05-18 16:51:54 +03:00
|
|
|
#include "mozilla/dom/FileBinding.h"
|
2013-09-20 14:21:03 +04:00
|
|
|
#include "mozilla/dom/DOMRect.h"
|
2013-01-15 16:22:03 +04:00
|
|
|
#include <algorithm>
|
2008-12-03 04:34:07 +03:00
|
|
|
|
2012-06-28 04:15:32 +04:00
|
|
|
#if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK)
|
2008-06-04 04:00:37 +04:00
|
|
|
#include <gdk/gdk.h>
|
2006-03-25 02:30:24 +03:00
|
|
|
#include <gdk/gdkx.h>
|
|
|
|
#endif
|
|
|
|
|
2010-09-03 22:01:05 +04:00
|
|
|
#include "Layers.h"
|
2014-07-24 07:14:02 +04:00
|
|
|
#include "gfxPrefs.h"
|
2010-09-03 22:01:05 +04:00
|
|
|
|
2017-07-18 11:09:10 +03:00
|
|
|
#include "mozilla/dom/AudioDeviceInfo.h"
|
2011-03-28 20:51:56 +04:00
|
|
|
#include "mozilla/dom/Element.h"
|
2014-04-05 01:50:42 +04:00
|
|
|
#include "mozilla/dom/TabChild.h"
|
2013-09-11 08:18:36 +04:00
|
|
|
#include "mozilla/dom/IDBFactoryBinding.h"
|
2014-07-17 20:40:54 +04:00
|
|
|
#include "mozilla/dom/IDBMutableFileBinding.h"
|
2016-02-17 00:46:08 +03:00
|
|
|
#include "mozilla/dom/IDBMutableFile.h"
|
|
|
|
#include "mozilla/dom/IndexedDatabaseManager.h"
|
2014-07-08 08:45:23 +04:00
|
|
|
#include "mozilla/dom/PermissionMessageUtils.h"
|
2013-09-11 08:18:36 +04:00
|
|
|
#include "mozilla/dom/quota/PersistenceType.h"
|
2013-03-26 15:13:17 +04:00
|
|
|
#include "mozilla/dom/quota/QuotaManager.h"
|
2017-06-15 21:34:00 +03:00
|
|
|
#include "mozilla/dom/ContentChild.h"
|
2015-06-08 19:53:41 +03:00
|
|
|
#include "mozilla/layers/FrameUniformityData.h"
|
|
|
|
#include "mozilla/layers/ShadowLayers.h"
|
2012-09-04 12:39:28 +04:00
|
|
|
#include "nsPrintfCString.h"
|
2012-12-18 01:24:41 +04:00
|
|
|
#include "nsViewportInfo.h"
|
2013-01-03 19:17:36 +04:00
|
|
|
#include "nsIFormControl.h"
|
2013-05-07 20:34:20 +04:00
|
|
|
#include "nsIScriptError.h"
|
Bug 1179909: Refactor stable state handling. r=smaug
This is motivated by three separate but related problems:
1. Our concept of recursion depth is broken for things that run from AfterProcessNextEvent observers (e.g. Promises). We decrement the recursionDepth counter before firing observers, so a Promise callback running at the lowest event loop depth has a recursion depth of 0 (whereas a regular nsIRunnable would be 1). This is a problem because it's impossible to distinguish a Promise running after a sync XHR's onreadystatechange handler from a top-level event (since the former runs with depth 2 - 1 = 1, and the latter runs with just 1).
2. The nsIThreadObserver mechanism that is used by a lot of code to run "after" the current event is a poor fit for anything that runs script. First, the order the observers fire in is the order they were added, not anything fixed by spec. Additionally, running script can cause the event loop to spin, which is a big source of pain here (bholley has some nasty bug caused by this).
3. We run Promises from different points in the code for workers and main thread. The latter runs from XPConnect's nsIThreadObserver callbacks, while the former runs from a hardcoded call to run Promises in the worker event loop. What workers do is particularly problematic because it means we can't get the right recursion depth no matter what we do to nsThread.
The solve this, this patch does the following:
1. Consolidate some handling of microtasks and all handling of stable state from appshell and WorkerPrivate into CycleCollectedJSRuntime.
2. Make the recursionDepth counter only available to CycleCollectedJSRuntime (and its consumers) and remove it from the nsIThreadInternal and nsIThreadObserver APIs.
3. Adjust the recursionDepth counter so that microtasks run with the recursionDepth of the task they are associated with.
4. Introduce the concept of metastable state to replace appshell's RunBeforeNextEvent. Metastable state is reached after every microtask or task is completed. This provides the semantics that bent and I want for IndexedDB, where transactions autocommit at the end of a microtask and do not "spill" from one microtask into a subsequent microtask. This differs from appshell's RunBeforeNextEvent in two ways:
a) It fires between microtasks, which was the motivation for starting this.
b) It no longer ensures that we're at the same event loop depth in the native event queue. bent decided we don't care about this.
5. Reorder stable state to happen after microtasks such as Promises, per HTML. Right now we call the regular thread observers, including appshell, before the main thread observer (XPConnect), so stable state tasks happen before microtasks.
2015-08-11 16:10:46 +03:00
|
|
|
//#include "nsWidgetsCID.h"
|
2013-05-30 04:38:27 +04:00
|
|
|
#include "FrameLayerBuilder.h"
|
|
|
|
#include "nsDisplayList.h"
|
|
|
|
#include "nsROCSSPrimitiveValue.h"
|
2013-08-15 22:17:48 +04:00
|
|
|
#include "nsIBaseWindow.h"
|
|
|
|
#include "nsIDocShellTreeOwner.h"
|
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
2013-09-11 00:56:05 +04:00
|
|
|
#include "GeckoProfiler.h"
|
2013-11-27 11:32:19 +04:00
|
|
|
#include "mozilla/Preferences.h"
|
2014-04-05 07:21:08 +04:00
|
|
|
#include "nsIContentIterator.h"
|
2015-07-08 08:57:31 +03:00
|
|
|
#include "nsIStyleSheetService.h"
|
2014-07-08 08:45:23 +04:00
|
|
|
#include "nsContentPermissionHelper.h"
|
2016-02-17 23:37:00 +03:00
|
|
|
#include "nsCSSPseudoElements.h" // for CSSPseudoElementType
|
2014-10-31 21:48:52 +03:00
|
|
|
#include "nsNetUtil.h"
|
2015-03-17 22:25:35 +03:00
|
|
|
#include "nsDocument.h"
|
|
|
|
#include "HTMLImageElement.h"
|
2017-09-28 22:17:07 +03:00
|
|
|
#include "HTMLCanvasElement.h"
|
2015-03-17 22:25:35 +03:00
|
|
|
#include "mozilla/css/ImageLoader.h"
|
2018-03-06 18:25:39 +03:00
|
|
|
#include "mozilla/layers/IAPZCTreeManager.h" // for layers::ZoomToRectBehavior
|
2016-01-25 13:29:28 +03:00
|
|
|
#include "mozilla/dom/Promise.h"
|
2016-09-26 15:03:25 +03:00
|
|
|
#include "mozilla/StyleSheetInlines.h"
|
2016-10-31 22:44:40 +03:00
|
|
|
#include "mozilla/gfx/GPUProcessManager.h"
|
2016-12-01 03:32:23 +03:00
|
|
|
#include "mozilla/dom/TimeoutManager.h"
|
2017-01-05 10:32:22 +03:00
|
|
|
#include "mozilla/PreloadedStyleSheet.h"
|
2017-05-28 14:48:36 +03:00
|
|
|
#include "mozilla/layers/WebRenderBridgeChild.h"
|
|
|
|
#include "mozilla/layers/WebRenderLayerManager.h"
|
2011-03-28 20:51:56 +04:00
|
|
|
|
2013-05-28 03:47:45 +04:00
|
|
|
#ifdef XP_WIN
|
|
|
|
#undef GetClassName
|
|
|
|
#endif
|
|
|
|
|
2012-04-25 07:00:02 +04:00
|
|
|
using namespace mozilla;
|
2011-03-28 20:51:56 +04:00
|
|
|
using namespace mozilla::dom;
|
2014-09-27 03:21:57 +04:00
|
|
|
using namespace mozilla::ipc;
|
2010-09-03 22:01:05 +04:00
|
|
|
using namespace mozilla::layers;
|
2011-11-27 15:51:52 +04:00
|
|
|
using namespace mozilla::widget;
|
2013-12-12 01:05:27 +04:00
|
|
|
using namespace mozilla::gfx;
|
2010-09-03 22:01:05 +04:00
|
|
|
|
2013-08-15 22:17:48 +04:00
|
|
|
class gfxContext;
|
|
|
|
|
2016-06-21 01:19:50 +03:00
|
|
|
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) { }
|
2016-11-14 12:40:37 +03:00
|
|
|
~OldWindowSize() = default;;
|
2016-06-21 01:19:50 +03:00
|
|
|
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
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)
|
|
|
|
{
|
2017-07-28 10:14:54 +03:00
|
|
|
MOZ_ASSERT(NS_IsMainThread());
|
2017-05-19 10:41:24 +03:00
|
|
|
nsCOMPtr<nsIRunnable> event(new NativeInputRunnable(Move(aEvent)));
|
|
|
|
return event.forget();
|
|
|
|
}
|
|
|
|
|
|
|
|
} // unnamed namespace
|
|
|
|
|
2016-06-21 01:19:50 +03:00
|
|
|
LinkedList<OldWindowSize> OldWindowSize::sList;
|
|
|
|
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_INTERFACE_MAP_BEGIN(nsDOMWindowUtils)
|
2004-06-20 20:42:13 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMWindowUtils)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMWindowUtils)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
|
|
|
NS_INTERFACE_MAP_END
|
|
|
|
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_IMPL_ADDREF(nsDOMWindowUtils)
|
|
|
|
NS_IMPL_RELEASE(nsDOMWindowUtils)
|
2004-06-20 20:42:13 +04:00
|
|
|
|
2017-11-04 01:25:38 +03:00
|
|
|
nsDOMWindowUtils::nsDOMWindowUtils(nsGlobalWindowOuter *aWindow)
|
2004-12-10 22:48:22 +03:00
|
|
|
{
|
2012-04-02 06:23:51 +04:00
|
|
|
nsCOMPtr<nsISupports> supports = do_QueryObject(aWindow);
|
|
|
|
mWindow = do_GetWeakReference(supports);
|
2004-06-21 00:37:16 +04:00
|
|
|
}
|
2004-06-20 20:42:13 +04:00
|
|
|
|
2004-12-10 22:48:22 +03:00
|
|
|
nsDOMWindowUtils::~nsDOMWindowUtils()
|
|
|
|
{
|
2016-06-21 01:19:50 +03:00
|
|
|
OldWindowSize::GetAndRemove(mWindow);
|
2004-06-21 00:37:16 +04:00
|
|
|
}
|
2004-06-20 20:42:13 +04:00
|
|
|
|
2010-09-04 00:10:45 +04:00
|
|
|
nsIPresShell*
|
|
|
|
nsDOMWindowUtils::GetPresShell()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
if (!window)
|
2012-07-30 18:20:58 +04:00
|
|
|
return nullptr;
|
2010-09-04 00:10:45 +04:00
|
|
|
|
2012-04-02 06:23:51 +04:00
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2010-09-04 00:10:45 +04:00
|
|
|
if (!docShell)
|
2012-07-30 18:20:58 +04:00
|
|
|
return nullptr;
|
2010-09-04 00:10:45 +04:00
|
|
|
|
2012-12-29 05:56:42 +04:00
|
|
|
return docShell->GetPresShell();
|
2010-09-04 00:10:45 +04:00
|
|
|
}
|
|
|
|
|
2009-01-06 04:15:13 +03:00
|
|
|
nsPresContext*
|
|
|
|
nsDOMWindowUtils::GetPresContext()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
if (!window)
|
2012-07-30 18:20:58 +04:00
|
|
|
return nullptr;
|
2012-04-02 06:23:51 +04:00
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2009-01-06 04:15:13 +03:00
|
|
|
if (!docShell)
|
2012-07-30 18:20:58 +04:00
|
|
|
return nullptr;
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<nsPresContext> presContext;
|
2009-01-06 04:15:13 +03:00
|
|
|
docShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
return presContext;
|
|
|
|
}
|
|
|
|
|
2014-03-08 13:22:28 +04:00
|
|
|
nsIDocument*
|
|
|
|
nsDOMWindowUtils::GetDocument()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2014-03-08 13:22:28 +04:00
|
|
|
if (!window) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return window->GetExtantDoc();
|
|
|
|
}
|
|
|
|
|
2014-03-22 01:59:57 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-06-28 03:29:06 +03:00
|
|
|
WebRenderBridgeChild*
|
|
|
|
nsDOMWindowUtils::GetWebRenderBridge()
|
|
|
|
{
|
|
|
|
if (nsIWidget* widget = GetWidget()) {
|
|
|
|
if (LayerManager* lm = widget->GetLayerManager()) {
|
|
|
|
if (WebRenderLayerManager* wrlm = lm->AsWebRenderLayerManager()) {
|
|
|
|
return wrlm->WrBridge();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2004-06-20 20:42:13 +04:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::GetImageAnimationMode(uint16_t *aMode)
|
2004-12-10 22:48:22 +03:00
|
|
|
{
|
2004-06-20 20:42:13 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aMode);
|
|
|
|
*aMode = 0;
|
2009-01-06 04:15:13 +03:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
|
|
|
*aMode = presContext->ImageAnimationMode();
|
|
|
|
return NS_OK;
|
2004-06-20 20:42:13 +04:00
|
|
|
}
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::SetImageAnimationMode(uint16_t aMode)
|
2004-12-10 22:48:22 +03:00
|
|
|
{
|
2009-01-06 04:15:13 +03:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
|
|
|
presContext->SetImageAnimationMode(aMode);
|
|
|
|
return NS_OK;
|
2004-06-20 20:42:13 +04:00
|
|
|
}
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
2004-11-18 23:50:16 +03:00
|
|
|
|
2007-08-11 22:37:16 +04:00
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsDOMWindowUtils::GetDocCharsetIsForced(bool *aIsForced)
|
2007-08-11 22:37:16 +04:00
|
|
|
{
|
2011-10-17 18:59:28 +04:00
|
|
|
*aIsForced = false;
|
2007-08-11 22:37:16 +04:00
|
|
|
|
2014-03-08 13:22:28 +04:00
|
|
|
nsIDocument* doc = GetDocument();
|
|
|
|
*aIsForced = doc &&
|
|
|
|
doc->GetDocumentCharacterSetSource() >= kCharsetFromParentForced;
|
2007-08-11 22:37:16 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2017-11-12 17:56:12 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetPhysicalMillimeterInCSSPixels(float* aPhysicalMillimeter)
|
|
|
|
{
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
2018-03-16 16:29:15 +03:00
|
|
|
*aPhysicalMillimeter = nsPresContext::AppUnitsToFloatCSSPixels(
|
2017-11-12 17:56:12 +03:00
|
|
|
presContext->PhysicalMillimetersToAppUnits(1));
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2004-11-18 23:50:16 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetDocumentMetadata(const nsAString& aName,
|
|
|
|
nsAString& aValue)
|
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsIDocument* doc = GetDocument();
|
|
|
|
if (doc) {
|
2017-10-03 01:05:19 +03:00
|
|
|
RefPtr<nsAtom> name = NS_Atomize(aName);
|
2014-03-08 13:22:28 +04:00
|
|
|
doc->GetHeaderData(name, aValue);
|
|
|
|
return NS_OK;
|
2004-11-18 23:50:16 +03:00
|
|
|
}
|
2013-04-24 08:22:37 +04:00
|
|
|
|
2004-11-18 23:50:16 +03:00
|
|
|
aValue.Truncate();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2005-10-22 02:30:36 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::Redraw(uint32_t aCount, uint32_t *aDurationOut)
|
2005-10-22 02:30:36 +04:00
|
|
|
{
|
2008-06-04 04:00:37 +04:00
|
|
|
if (aCount == 0)
|
|
|
|
aCount = 1;
|
|
|
|
|
2010-09-04 00:10:45 +04:00
|
|
|
if (nsIPresShell* presShell = GetPresShell()) {
|
|
|
|
nsIFrame *rootFrame = presShell->GetRootFrame();
|
2005-10-22 02:30:36 +04:00
|
|
|
|
2010-09-04 00:10:45 +04:00
|
|
|
if (rootFrame) {
|
|
|
|
PRIntervalTime iStart = PR_IntervalNow();
|
2008-06-04 04:00:37 +04:00
|
|
|
|
2012-08-22 19:56:38 +04:00
|
|
|
for (uint32_t i = 0; i < aCount; i++)
|
2012-08-29 09:39:31 +04:00
|
|
|
rootFrame->InvalidateFrame();
|
2008-06-04 04:00:37 +04:00
|
|
|
|
2012-06-28 04:15:32 +04:00
|
|
|
#if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK)
|
2017-04-04 17:22:00 +03:00
|
|
|
if (!gfxPlatform::IsHeadless()) {
|
|
|
|
XSync(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), False);
|
|
|
|
}
|
2006-03-25 02:30:24 +03:00
|
|
|
#endif
|
2008-06-04 04:00:37 +04:00
|
|
|
|
2010-09-04 00:10:45 +04:00
|
|
|
*aDurationOut = PR_IntervalToMilliseconds(PR_IntervalNow() - iStart);
|
2008-06-04 04:00:37 +04:00
|
|
|
|
2010-09-04 00:10:45 +04:00
|
|
|
return NS_OK;
|
2005-10-22 02:30:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2007-02-27 00:14:19 +03:00
|
|
|
|
2014-11-04 07:05:44 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::UpdateLayerTree()
|
|
|
|
{
|
|
|
|
if (nsIPresShell* presShell = GetPresShell()) {
|
2018-03-22 08:08:29 +03:00
|
|
|
// Don't flush throttled animations since it might fire MozAfterPaint event
|
|
|
|
// (in WebRender it constantly does), thus the reftest harness can't take
|
|
|
|
// any snapshot until the throttled animations finished.
|
|
|
|
presShell->FlushPendingNotifications(
|
|
|
|
ChangesToFlush(FlushType::Display, false /* flush animations */));
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<nsViewManager> vm = presShell->GetViewManager();
|
2014-11-07 03:20:27 +03:00
|
|
|
nsView* view = vm->GetRootView();
|
|
|
|
if (view) {
|
|
|
|
presShell->Paint(view, view->GetBounds(),
|
|
|
|
nsIPresShell::PAINT_LAYERS | nsIPresShell::PAINT_SYNC_DECODE_IMAGES);
|
2017-05-15 20:03:32 +03:00
|
|
|
presShell->GetLayerManager()->WaitOnTransactionProcessed();
|
2014-11-07 03:20:27 +03:00
|
|
|
}
|
2014-11-04 07:05:44 +03:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-07-01 00:15:41 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-08-23 00:17:20 +04:00
|
|
|
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)
|
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsIDocument* doc = GetDocument();
|
2012-08-23 00:17:20 +04:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
2015-10-23 20:21:57 +03:00
|
|
|
nsViewportInfo info = doc->GetViewportInfo(ScreenIntSize(aDisplayWidth, aDisplayHeight));
|
2013-09-03 23:12:23 +04:00
|
|
|
*aDefaultZoom = info.GetDefaultZoom().scale;
|
2012-12-18 01:24:41 +04:00
|
|
|
*aAllowZoom = info.IsZoomAllowed();
|
2013-09-03 23:12:23 +04:00
|
|
|
*aMinZoom = info.GetMinZoom().scale;
|
|
|
|
*aMaxZoom = info.GetMaxZoom().scale;
|
2014-05-29 00:27:38 +04:00
|
|
|
CSSIntSize size = gfx::RoundedToInt(info.GetSize());
|
|
|
|
*aWidth = size.width;
|
|
|
|
*aHeight = size.height;
|
2012-12-18 01:24:41 +04:00
|
|
|
*aAutoSize = info.IsAutoSizeEnabled();
|
2012-08-23 00:17:20 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-03-16 02:20:19 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetDisplayPortForElement(float aXPx, float aYPx,
|
|
|
|
float aWidthPx, float aHeightPx,
|
2014-03-08 13:25:15 +04:00
|
|
|
nsIDOMElement* aElement,
|
|
|
|
uint32_t aPriority)
|
2010-09-04 00:10:46 +04:00
|
|
|
{
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
2012-05-05 17:25:26 +04:00
|
|
|
}
|
2010-09-04 00:10:46 +04:00
|
|
|
|
2011-03-16 02:20:19 +03:00
|
|
|
if (!aElement) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
|
|
|
|
if (!content) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2016-03-31 14:46:32 +03:00
|
|
|
if (content->GetUncomposedDoc() != presShell->GetDocument()) {
|
2012-04-16 17:48:04 +04:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2014-03-08 13:25:15 +04:00
|
|
|
DisplayPortPropertyData* currentData =
|
|
|
|
static_cast<DisplayPortPropertyData*>(content->GetProperty(nsGkAtoms::DisplayPort));
|
|
|
|
if (currentData && currentData->mPriority > aPriority) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-03-27 05:46:24 +04:00
|
|
|
nsRect displayport(nsPresContext::CSSPixelsToAppUnits(aXPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aYPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aWidthPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aHeightPx));
|
|
|
|
|
2014-03-08 13:25:15 +04:00
|
|
|
content->SetProperty(nsGkAtoms::DisplayPort,
|
|
|
|
new DisplayPortPropertyData(displayport, aPriority),
|
2014-03-25 17:25:47 +04:00
|
|
|
nsINode::DeleteProperty<DisplayPortPropertyData>);
|
2011-03-16 02:20:19 +03:00
|
|
|
|
2015-06-04 23:51:10 +03:00
|
|
|
if (gfxPrefs::LayoutUseContainersForRootFrames()) {
|
2014-07-24 07:14:02 +04:00
|
|
|
nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
|
2015-06-04 23:51:10 +03:00
|
|
|
if (rootScrollFrame &&
|
|
|
|
content == rootScrollFrame->GetContent() &&
|
|
|
|
nsLayoutUtils::UsesAsyncScrolling(rootScrollFrame))
|
|
|
|
{
|
2014-07-24 07:14:02 +04:00
|
|
|
// We are setting a root displayport for a document.
|
|
|
|
// The pres shell needs a special flag set.
|
|
|
|
presShell->SetIgnoreViewportScrolling(true);
|
|
|
|
}
|
2011-03-16 02:20:19 +03:00
|
|
|
}
|
|
|
|
|
2017-09-29 00:54:15 +03:00
|
|
|
nsLayoutUtils::InvalidateForDisplayPortChange(content, !!currentData,
|
|
|
|
currentData ? currentData->mRect : nsRect(), displayport);
|
|
|
|
|
2018-03-06 12:25:21 +03:00
|
|
|
nsIFrame* rootFrame = presShell->GetRootFrame();
|
2012-05-05 17:25:26 +04:00
|
|
|
if (rootFrame) {
|
2012-12-17 04:20:02 +04:00
|
|
|
rootFrame->SchedulePaint();
|
2012-05-05 17:25:26 +04:00
|
|
|
|
|
|
|
// 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) {
|
2016-06-24 03:53:27 +03:00
|
|
|
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);
|
2011-10-18 23:28:39 +04:00
|
|
|
}
|
2011-03-16 02:20:19 +03:00
|
|
|
}
|
|
|
|
}
|
2010-09-04 00:10:46 +04:00
|
|
|
|
2012-11-22 02:34:18 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-03-27 05:46:23 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-03-31 14:46:32 +03:00
|
|
|
if (content->GetUncomposedDoc() != presShell->GetDocument()) {
|
2014-03-27 05:46:23 +04:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2014-03-27 05:46:24 +04:00
|
|
|
// Note order change of arguments between our function signature and
|
2014-10-24 23:49:38 +04:00
|
|
|
// ScreenMargin constructor.
|
|
|
|
ScreenMargin displayportMargins(aTopMargin,
|
|
|
|
aRightMargin,
|
|
|
|
aBottomMargin,
|
|
|
|
aLeftMargin);
|
2014-03-27 05:46:24 +04:00
|
|
|
|
2014-04-04 18:13:50 +04:00
|
|
|
nsLayoutUtils::SetDisplayPortMargins(content, presShell, displayportMargins,
|
2014-11-13 01:54:29 +03:00
|
|
|
aPriority);
|
2014-03-27 05:46:23 +04:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-03-31 14:46:32 +03:00
|
|
|
if (content->GetUncomposedDoc() != presShell->GetDocument()) {
|
2014-03-27 05:46:23 +04:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2014-04-04 18:13:50 +04:00
|
|
|
nsLayoutUtils::SetDisplayPortBase(content, nsRect(aX, aY, aWidth, aHeight));
|
2014-03-27 05:46:23 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-09-04 00:10:46 +04:00
|
|
|
NS_IMETHODIMP
|
2015-03-07 02:07:59 +03:00
|
|
|
nsDOMWindowUtils::SetResolution(float aResolution)
|
2010-09-04 00:10:46 +04:00
|
|
|
{
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
2014-04-07 15:43:58 +04:00
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2015-11-23 17:14:15 +03:00
|
|
|
presShell->SetResolution(aResolution);
|
2014-04-07 15:43:58 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
2010-09-04 00:10:46 +04:00
|
|
|
}
|
|
|
|
|
2015-01-03 04:06:14 +03:00
|
|
|
NS_IMETHODIMP
|
2015-03-07 02:07:59 +03:00
|
|
|
nsDOMWindowUtils::SetResolutionAndScaleTo(float aResolution)
|
2015-01-03 04:06:14 +03:00
|
|
|
{
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2015-11-23 17:14:18 +03:00
|
|
|
presShell->SetResolutionAndScaleTo(aResolution);
|
2015-01-03 04:06:14 +03:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-05-17 21:50:08 +03:00
|
|
|
NS_IMETHODIMP
|
Bug 1282902 - Part 3 - Let the MobileViewportManager recalculate the saved resolution if the display width changed before restoring. r=kats
The mobile session store saves the current document resolution in order to restore the previous zoom level when restoring a page. If the display width has changed since the session data was captured (e.g. because the device was rotated), the resolution might have to be scaled appropriately.
Currently, the session store does this scaling by itself by comparing the stored and current window widths, however this implementation is slightly simplified and doesn't cover all use cases, which means some pages can be restored at a wrong zoom level after rotation. To correctly cover all cases, the session store would have to compare viewport widths, too.
Because the MobileViewportManager doesn't wait for the session store to set the restore resolution, the latter has to call setRestoreResolution() as early as possible in order to guarantee that the restore resolution is set before the first paint of the document. Therefore the session store currently calls this after receiving a LocationChange notification. However at that time, the correct viewport for the current document is not yet available, which means the resolution cannot be recalculated by the session store at that point.
Therefore, this patch changes the approach taken and lets the MVM handle all resolution calculations instead. The session store now simply passes the stored previous display dimensions along with the previous document resolution to the MVM, which can then compare them to the current display and viewport widths and scale the resolution appropriately before using it during first paint.
MozReview-Commit-ID: IGxWw87yftK
--HG--
extra : transplant_source : e%8D%BD%26%D2%C3%8E5%E3%2B%C0t%BA%DB%C1%BBs%3F%13%1F
2016-07-01 22:23:25 +03:00
|
|
|
nsDOMWindowUtils::SetRestoreResolution(float aResolution,
|
|
|
|
uint32_t aDisplayWidth,
|
|
|
|
uint32_t aDisplayHeight)
|
2016-05-17 21:50:08 +03:00
|
|
|
{
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
Bug 1282902 - Part 3 - Let the MobileViewportManager recalculate the saved resolution if the display width changed before restoring. r=kats
The mobile session store saves the current document resolution in order to restore the previous zoom level when restoring a page. If the display width has changed since the session data was captured (e.g. because the device was rotated), the resolution might have to be scaled appropriately.
Currently, the session store does this scaling by itself by comparing the stored and current window widths, however this implementation is slightly simplified and doesn't cover all use cases, which means some pages can be restored at a wrong zoom level after rotation. To correctly cover all cases, the session store would have to compare viewport widths, too.
Because the MobileViewportManager doesn't wait for the session store to set the restore resolution, the latter has to call setRestoreResolution() as early as possible in order to guarantee that the restore resolution is set before the first paint of the document. Therefore the session store currently calls this after receiving a LocationChange notification. However at that time, the correct viewport for the current document is not yet available, which means the resolution cannot be recalculated by the session store at that point.
Therefore, this patch changes the approach taken and lets the MVM handle all resolution calculations instead. The session store now simply passes the stored previous display dimensions along with the previous document resolution to the MVM, which can then compare them to the current display and viewport widths and scale the resolution appropriately before using it during first paint.
MozReview-Commit-ID: IGxWw87yftK
--HG--
extra : transplant_source : e%8D%BD%26%D2%C3%8E5%E3%2B%C0t%BA%DB%C1%BBs%3F%13%1F
2016-07-01 22:23:25 +03:00
|
|
|
presShell->SetRestoreResolution(aResolution,
|
|
|
|
LayoutDeviceIntSize(aDisplayWidth, aDisplayHeight));
|
2016-05-17 21:50:08 +03:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-10-27 01:09:38 +04:00
|
|
|
NS_IMETHODIMP
|
2015-03-07 02:07:59 +03:00
|
|
|
nsDOMWindowUtils::GetResolution(float* aResolution)
|
2012-10-27 01:09:38 +04:00
|
|
|
{
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
2014-04-07 15:43:58 +04:00
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2012-10-27 01:09:38 +04:00
|
|
|
|
2015-11-23 17:14:18 +03:00
|
|
|
*aResolution = presShell->GetResolution();
|
2014-04-07 15:43:58 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
2012-10-27 01:09:38 +04:00
|
|
|
}
|
|
|
|
|
2014-05-06 01:29:20 +04:00
|
|
|
NS_IMETHODIMP
|
2014-05-12 21:26:53 +04:00
|
|
|
nsDOMWindowUtils::GetIsResolutionSet(bool* aIsResolutionSet) {
|
2014-05-06 01:29:20 +04:00
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2015-11-23 17:14:15 +03:00
|
|
|
*aIsResolutionSet = presShell->IsResolutionSet();
|
2014-05-06 01:29:20 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-03-12 19:50:11 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-05-24 05:43:36 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetPresShellId(uint32_t *aPresShellId)
|
|
|
|
{
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (presShell) {
|
|
|
|
*aPresShellId = presShell->GetPresShellId();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:19 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendMouseEvent(const nsAString& aType,
|
2008-11-27 00:52:42 +03:00
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 19:56:38 +04:00
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
2012-08-14 18:27:39 +04:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
float aPressure,
|
2013-02-06 01:40:34 +04:00
|
|
|
unsigned short aInputSourceArg,
|
2016-07-07 10:28:11 +03:00
|
|
|
bool aIsDOMEventSynthesized,
|
|
|
|
bool aIsWidgetEventSynthesized,
|
2016-08-18 06:58:48 +03:00
|
|
|
int32_t aButtons,
|
2016-12-21 07:06:00 +03:00
|
|
|
uint32_t aIdentifier,
|
2014-01-15 18:28:04 +04:00
|
|
|
uint8_t aOptionalArgCount,
|
2013-02-06 01:40:34 +04:00
|
|
|
bool *aPreventDefault)
|
2010-08-28 03:15:07 +04:00
|
|
|
{
|
|
|
|
return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
|
2012-08-25 20:04:14 +04:00
|
|
|
aIgnoreRootScrollFrame, aPressure,
|
2016-12-21 07:06:00 +03:00
|
|
|
aInputSourceArg,
|
|
|
|
aOptionalArgCount >= 7 ?
|
|
|
|
aIdentifier : DEFAULT_MOUSE_POINTER_ID,
|
|
|
|
false, aPreventDefault,
|
2016-07-07 10:28:11 +03:00
|
|
|
aOptionalArgCount >= 4 ?
|
|
|
|
aIsDOMEventSynthesized : true,
|
|
|
|
aOptionalArgCount >= 5 ?
|
2016-08-18 06:58:48 +03:00
|
|
|
aIsWidgetEventSynthesized : false,
|
|
|
|
aOptionalArgCount >= 6 ?
|
|
|
|
aButtons : MOUSE_BUTTONS_NOT_SPECIFIED);
|
2010-08-28 03:15:07 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendMouseEventToWindow(const nsAString& aType,
|
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 19:56:38 +04:00
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
2012-08-14 18:27:39 +04:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
float aPressure,
|
2014-01-15 18:28:04 +04:00
|
|
|
unsigned short aInputSourceArg,
|
2016-07-07 10:28:11 +03:00
|
|
|
bool aIsDOMEventSynthesized,
|
|
|
|
bool aIsWidgetEventSynthesized,
|
2016-08-18 06:58:48 +03:00
|
|
|
int32_t aButtons,
|
2016-12-21 07:06:00 +03:00
|
|
|
uint32_t aIdentifier,
|
2014-01-15 18:28:04 +04:00
|
|
|
uint8_t aOptionalArgCount)
|
2010-08-28 03:15:07 +04:00
|
|
|
{
|
Bug 1375392 - Tweak the PROFILER_LABEL* macros. r=mstange.
This patch makes the following changes to the macros.
- Removes PROFILER_LABEL_FUNC. It's only suitable for use in functions outside
classes, due to PROFILER_FUNCTION_NAME not getting class names, and it was
mostly misused.
- Removes PROFILER_FUNCTION_NAME. It's no longer used, and __func__ is
universally available now anyway.
- Combines the first two string literal arguments of PROFILER_LABEL and
PROFILER_LABEL_DYNAMIC into a single argument. There was no good reason for
them to be separate, and it forced a '::' in the label, which isn't always
appropriate. Also, the meaning of the "name_space" argument was interpreted
in an interesting variety of ways.
- Adds an "AUTO_" prefix to PROFILER_LABEL and PROFILER_LABEL_DYNAMIC, to make
it clearer they construct RAII objects rather than just being function calls.
(I myself have screwed up the scoping because of this in the past.)
- Fills in the 'js::ProfileEntry::Category::' qualifier within the macro, so
the caller doesn't need to. This makes a *lot* more of the uses fit onto a
single line.
The patch also makes the following changes to the macro uses (beyond those
required by the changes described above).
- Fixes a bunch of labels that had gotten out of sync with the name of the
class and/or function that encloses them.
- Removes a useless PROFILER_LABEL use within a trivial scope in
EventStateManager::DispatchMouseOrPointerEvent(). It clearly wasn't serving
any useful purpose. It also serves as extra evidence that the AUTO_ prefix is
a good idea.
- Tweaks DecodePool::SyncRunIf{Preferred,Possible} so that the labelling is
done within them, instead of at their callsites, because that's a more
standard way of doing things.
--HG--
extra : rebase_source : 318d1bc6fc1425a94aacbf489dd46e4f83211de4
2017-06-22 10:08:53 +03:00
|
|
|
AUTO_PROFILER_LABEL("nsDOMWindowUtils::SendMouseEventToWindow", EVENTS);
|
2014-05-24 01:12:29 +04:00
|
|
|
|
2010-08-28 03:15:07 +04:00
|
|
|
return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
|
2012-08-25 20:04:14 +04:00
|
|
|
aIgnoreRootScrollFrame, aPressure,
|
2016-12-21 07:06:00 +03:00
|
|
|
aInputSourceArg,
|
|
|
|
aOptionalArgCount >= 7 ?
|
|
|
|
aIdentifier : DEFAULT_MOUSE_POINTER_ID,
|
|
|
|
true, nullptr,
|
2016-07-07 10:28:11 +03:00
|
|
|
aOptionalArgCount >= 4 ?
|
|
|
|
aIsDOMEventSynthesized : true,
|
|
|
|
aOptionalArgCount >= 5 ?
|
2016-08-18 06:58:48 +03:00
|
|
|
aIsWidgetEventSynthesized : false,
|
|
|
|
aOptionalArgCount >= 6 ?
|
|
|
|
aButtons : MOUSE_BUTTONS_NOT_SPECIFIED);
|
2010-08-28 03:15:07 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendMouseEventCommon(const nsAString& aType,
|
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 19:56:38 +04:00
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aIgnoreRootScrollFrame,
|
2012-08-14 18:27:39 +04:00
|
|
|
float aPressure,
|
|
|
|
unsigned short aInputSourceArg,
|
2016-12-21 07:06:00 +03:00
|
|
|
uint32_t aPointerId,
|
2013-02-06 01:40:34 +04:00
|
|
|
bool aToWindow,
|
2014-01-15 18:28:04 +04:00
|
|
|
bool *aPreventDefault,
|
2016-07-07 10:28:11 +03:00
|
|
|
bool aIsDOMEventSynthesized,
|
2016-08-18 06:58:48 +03:00
|
|
|
bool aIsWidgetEventSynthesized,
|
|
|
|
int32_t aButtons)
|
2007-02-27 00:14:19 +03:00
|
|
|
{
|
2015-04-15 10:08:55 +03:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = GetPresShell();
|
|
|
|
return nsContentUtils::SendMouseEvent(presShell, aType, aX, aY, aButton,
|
2016-08-18 06:58:48 +03:00
|
|
|
aButtons, aClickCount, aModifiers, aIgnoreRootScrollFrame, aPressure,
|
2016-12-21 07:06:00 +03:00
|
|
|
aInputSourceArg, aPointerId, aToWindow, aPreventDefault,
|
|
|
|
aIsDOMEventSynthesized, aIsWidgetEventSynthesized);
|
2007-02-27 00:14:19 +03:00
|
|
|
}
|
|
|
|
|
2008-08-13 07:08:59 +04:00
|
|
|
NS_IMETHODIMP
|
2012-08-12 05:42:36 +04:00
|
|
|
nsDOMWindowUtils::SendWheelEvent(float aX,
|
|
|
|
float aY,
|
|
|
|
double aDeltaX,
|
|
|
|
double aDeltaY,
|
|
|
|
double aDeltaZ,
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t aDeltaMode,
|
|
|
|
int32_t aModifiers,
|
|
|
|
int32_t aLineOrPageDeltaX,
|
|
|
|
int32_t aLineOrPageDeltaY,
|
|
|
|
uint32_t aOptions)
|
2008-08-13 07:08:59 +04:00
|
|
|
{
|
|
|
|
// get the widget to send the event to
|
2008-11-27 00:52:42 +03:00
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
2012-08-12 05:42:36 +04:00
|
|
|
if (!widget) {
|
2008-08-13 07:08:59 +04:00
|
|
|
return NS_ERROR_NULL_POINTER;
|
2012-08-12 05:42:36 +04:00
|
|
|
}
|
2008-08-13 07:08:59 +04:00
|
|
|
|
2015-09-10 19:59:54 +03:00
|
|
|
WidgetWheelEvent wheelEvent(true, eWheel, widget);
|
2016-03-31 11:03:00 +03:00
|
|
|
wheelEvent.mModifiers = nsContentUtils::GetWidgetModifiers(aModifiers);
|
2016-03-31 12:55:59 +03:00
|
|
|
wheelEvent.mDeltaX = aDeltaX;
|
2016-03-31 12:09:47 +03:00
|
|
|
wheelEvent.mDeltaY = aDeltaY;
|
2016-03-31 12:18:34 +03:00
|
|
|
wheelEvent.mDeltaZ = aDeltaZ;
|
2016-03-31 12:35:24 +03:00
|
|
|
wheelEvent.mDeltaMode = aDeltaMode;
|
2016-03-31 17:45:55 +03:00
|
|
|
wheelEvent.mIsMomentum =
|
2012-08-12 05:42:36 +04:00
|
|
|
(aOptions & WHEEL_EVENT_CAUSED_BY_MOMENTUM) != 0;
|
2014-07-07 13:54:14 +04:00
|
|
|
wheelEvent.mIsNoLineOrPageDelta =
|
|
|
|
(aOptions & WHEEL_EVENT_CAUSED_BY_NO_LINE_OR_PAGE_DELTA_DEVICE) != 0;
|
2016-03-31 12:44:01 +03:00
|
|
|
wheelEvent.mCustomizedByUserPrefs =
|
2012-08-12 05:42:36 +04:00
|
|
|
(aOptions & WHEEL_EVENT_CUSTOMIZED_BY_USER_PREFS) != 0;
|
2016-03-31 18:10:46 +03:00
|
|
|
wheelEvent.mLineOrPageDeltaX = aLineOrPageDeltaX;
|
2016-03-31 18:10:09 +03:00
|
|
|
wheelEvent.mLineOrPageDeltaY = aLineOrPageDeltaY;
|
2012-08-12 05:42:36 +04:00
|
|
|
|
2016-03-28 07:29:42 +03:00
|
|
|
wheelEvent.mTime = PR_Now() / 1000;
|
2008-11-27 00:52:42 +03:00
|
|
|
|
2010-07-19 06:23:48 +04:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
2012-08-12 05:42:36 +04:00
|
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
2010-07-19 06:23:48 +04:00
|
|
|
|
2016-04-18 17:09:02 +03:00
|
|
|
wheelEvent.mRefPoint =
|
|
|
|
nsContentUtils::ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
|
2008-08-13 07:08:59 +04:00
|
|
|
|
2016-03-11 02:25:48 +03:00
|
|
|
widget->DispatchInputEvent(&wheelEvent);
|
2012-09-04 12:39:28 +04:00
|
|
|
|
2015-06-04 23:51:10 +03:00
|
|
|
if (widget->AsyncPanZoomEnabled()) {
|
2015-04-13 07:51:43 +03:00
|
|
|
// Computing overflow deltas is not compatible with APZ, so if APZ is
|
|
|
|
// enabled, we skip testing it.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-09-04 12:39:28 +04:00
|
|
|
bool failedX = false;
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_ZERO) &&
|
2016-03-31 18:27:45 +03:00
|
|
|
wheelEvent.mOverflowDeltaX != 0) {
|
2012-09-04 12:39:28 +04:00
|
|
|
failedX = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_POSITIVE) &&
|
2016-03-31 18:27:45 +03:00
|
|
|
wheelEvent.mOverflowDeltaX <= 0) {
|
2012-09-04 12:39:28 +04:00
|
|
|
failedX = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_NEGATIVE) &&
|
2016-03-31 18:27:45 +03:00
|
|
|
wheelEvent.mOverflowDeltaX >= 0) {
|
2012-09-04 12:39:28 +04:00
|
|
|
failedX = true;
|
|
|
|
}
|
|
|
|
bool failedY = false;
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_ZERO) &&
|
2016-03-31 18:36:55 +03:00
|
|
|
wheelEvent.mOverflowDeltaY != 0) {
|
2012-09-04 12:39:28 +04:00
|
|
|
failedY = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_POSITIVE) &&
|
2016-03-31 18:36:55 +03:00
|
|
|
wheelEvent.mOverflowDeltaY <= 0) {
|
2012-09-04 12:39:28 +04:00
|
|
|
failedY = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_NEGATIVE) &&
|
2016-03-31 18:36:55 +03:00
|
|
|
wheelEvent.mOverflowDeltaY >= 0) {
|
2012-09-04 12:39:28 +04:00
|
|
|
failedY = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
if (failedX) {
|
2016-03-31 18:27:45 +03:00
|
|
|
nsPrintfCString debugMsg("SendWheelEvent(): unexpected mOverflowDeltaX: %f",
|
|
|
|
wheelEvent.mOverflowDeltaX);
|
2012-09-04 12:39:28 +04:00
|
|
|
NS_WARNING(debugMsg.get());
|
|
|
|
}
|
|
|
|
if (failedY) {
|
2016-03-31 18:36:55 +03:00
|
|
|
nsPrintfCString debugMsg("SendWheelEvent(): unexpected mOverflowDeltaY: %f",
|
|
|
|
wheelEvent.mOverflowDeltaY);
|
2012-09-04 12:39:28 +04:00
|
|
|
NS_WARNING(debugMsg.get());
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return (!failedX && !failedY) ? NS_OK : NS_ERROR_FAILURE;
|
2008-08-13 07:08:59 +04:00
|
|
|
}
|
|
|
|
|
2011-12-17 04:24:11 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendTouchEvent(const nsAString& aType,
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t *aIdentifiers,
|
|
|
|
int32_t *aXs,
|
|
|
|
int32_t *aYs,
|
|
|
|
uint32_t *aRxs,
|
|
|
|
uint32_t *aRys,
|
2011-12-17 04:24:11 +04:00
|
|
|
float *aRotationAngles,
|
|
|
|
float *aForces,
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t aCount,
|
|
|
|
int32_t aModifiers,
|
2011-12-17 04:24:11 +04:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool *aPreventDefault)
|
2013-12-03 19:10:47 +04:00
|
|
|
{
|
|
|
|
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)
|
2011-12-17 04:24:11 +04:00
|
|
|
{
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
2015-08-26 15:56:59 +03:00
|
|
|
EventMessage msg;
|
2011-12-17 04:24:11 +04:00
|
|
|
if (aType.EqualsLiteral("touchstart")) {
|
2015-09-14 18:14:34 +03:00
|
|
|
msg = eTouchStart;
|
2011-12-17 04:24:11 +04:00
|
|
|
} else if (aType.EqualsLiteral("touchmove")) {
|
2015-09-14 18:14:35 +03:00
|
|
|
msg = eTouchMove;
|
2011-12-17 04:24:11 +04:00
|
|
|
} else if (aType.EqualsLiteral("touchend")) {
|
2015-09-14 18:14:35 +03:00
|
|
|
msg = eTouchEnd;
|
2011-12-17 04:24:11 +04:00
|
|
|
} else if (aType.EqualsLiteral("touchcancel")) {
|
2015-09-14 18:14:35 +03:00
|
|
|
msg = eTouchCancel;
|
2011-12-17 04:24:11 +04:00
|
|
|
} else {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
2013-09-27 10:20:57 +04:00
|
|
|
WidgetTouchEvent event(true, msg, widget);
|
2016-03-31 11:03:00 +03:00
|
|
|
event.mModifiers = nsContentUtils::GetWidgetModifiers(aModifiers);
|
2016-03-28 07:29:42 +03:00
|
|
|
event.mTime = PR_Now();
|
2011-12-17 04:24:11 +04:00
|
|
|
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2016-03-30 12:44:28 +03:00
|
|
|
event.mTouches.SetCapacity(aCount);
|
2012-08-22 19:56:38 +04:00
|
|
|
for (uint32_t i = 0; i < aCount; ++i) {
|
2013-08-02 11:05:16 +04:00
|
|
|
LayoutDeviceIntPoint pt =
|
2015-04-15 10:08:55 +03:00
|
|
|
nsContentUtils::ToWidgetPoint(CSSPoint(aXs[i], aYs[i]), offset, presContext);
|
2015-11-10 08:37:31 +03:00
|
|
|
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]);
|
|
|
|
|
2016-03-30 12:44:28 +03:00
|
|
|
event.mTouches.AppendElement(t);
|
2011-12-17 04:24:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsEventStatus status;
|
2013-12-03 19:10:47 +04:00
|
|
|
if (aToWindow) {
|
2014-07-09 09:03:00 +04:00
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
2015-04-15 10:08:55 +03:00
|
|
|
nsView* view = nsContentUtils::GetViewToDispatchEvent(presContext, getter_AddRefs(presShell));
|
2014-07-09 09:03:00 +04:00
|
|
|
if (!presShell || !view) {
|
2013-12-03 19:10:47 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
status = nsEventStatus_eIgnore;
|
|
|
|
*aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
|
|
|
|
return presShell->HandleEvent(view->GetFrame(), &event, false, &status);
|
|
|
|
}
|
|
|
|
|
2011-12-17 04:24:11 +04:00
|
|
|
nsresult rv = widget->DispatchEvent(&event, status);
|
|
|
|
*aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2008-05-06 03:01:07 +04:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::SendNativeKeyEvent(int32_t aNativeKeyboardLayout,
|
|
|
|
int32_t aNativeKeyCode,
|
|
|
|
int32_t aModifiers,
|
2008-05-06 03:01:07 +04:00
|
|
|
const nsAString& aCharacters,
|
2015-04-14 18:36:36 +03:00
|
|
|
const nsAString& aUnmodifiedCharacters,
|
|
|
|
nsIObserver* aObserver)
|
2008-05-06 03:01:07 +04:00
|
|
|
{
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
NS_DispatchToMainThread(NativeInputRunnable::Create(
|
2017-06-12 22:34:10 +03:00
|
|
|
NewRunnableMethod<int32_t,
|
|
|
|
int32_t,
|
|
|
|
uint32_t,
|
|
|
|
nsString,
|
|
|
|
nsString,
|
|
|
|
nsIObserver*>("nsIWidget::SynthesizeNativeKeyEvent",
|
|
|
|
widget,
|
|
|
|
&nsIWidget::SynthesizeNativeKeyEvent,
|
|
|
|
aNativeKeyboardLayout,
|
|
|
|
aNativeKeyCode,
|
|
|
|
aModifiers,
|
|
|
|
aCharacters,
|
|
|
|
aUnmodifiedCharacters,
|
2017-05-19 10:41:24 +03:00
|
|
|
aObserver)));
|
2015-04-14 18:36:36 +03:00
|
|
|
return NS_OK;
|
2008-05-06 03:01:07 +04:00
|
|
|
}
|
|
|
|
|
2009-09-23 06:31:37 +04:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::SendNativeMouseEvent(int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
|
|
|
int32_t aNativeMessage,
|
|
|
|
int32_t aModifierFlags,
|
2015-04-14 18:36:36 +03:00
|
|
|
nsIDOMElement* aElement,
|
|
|
|
nsIObserver* aObserver)
|
2009-09-23 06:31:37 +04:00
|
|
|
{
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
NS_DispatchToMainThread(NativeInputRunnable::Create(
|
2017-06-12 22:34:10 +03:00
|
|
|
NewRunnableMethod<LayoutDeviceIntPoint, int32_t, int32_t, nsIObserver*>(
|
|
|
|
"nsIWidget::SynthesizeNativeMouseEvent",
|
|
|
|
widget,
|
|
|
|
&nsIWidget::SynthesizeNativeMouseEvent,
|
|
|
|
LayoutDeviceIntPoint(aScreenX, aScreenY),
|
|
|
|
aNativeMessage,
|
|
|
|
aModifierFlags,
|
2017-05-19 10:41:24 +03:00
|
|
|
aObserver)));
|
2015-04-14 18:36:36 +03:00
|
|
|
return NS_OK;
|
2009-09-23 06:31:37 +04:00
|
|
|
}
|
|
|
|
|
2016-01-13 02:29:09 +03:00
|
|
|
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;
|
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
NS_DispatchToMainThread(NativeInputRunnable::Create(
|
|
|
|
NewRunnableMethod<LayoutDeviceIntPoint, nsIObserver*>(
|
|
|
|
"nsIWidget::SynthesizeNativeMouseMove",
|
|
|
|
widget,
|
|
|
|
&nsIWidget::SynthesizeNativeMouseMove,
|
|
|
|
LayoutDeviceIntPoint(aScreenX, aScreenY),
|
|
|
|
aObserver)));
|
2016-01-13 02:29:09 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-03-22 04:59:12 +04:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::SendNativeMouseScrollEvent(int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
|
|
|
uint32_t aNativeMessage,
|
2012-03-22 04:59:12 +04:00
|
|
|
double aDeltaX,
|
|
|
|
double aDeltaY,
|
|
|
|
double aDeltaZ,
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t aModifierFlags,
|
|
|
|
uint32_t aAdditionalFlags,
|
2015-04-14 18:36:36 +03:00
|
|
|
nsIDOMElement* aElement,
|
|
|
|
nsIObserver* aObserver)
|
2012-03-22 04:59:12 +04:00
|
|
|
{
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
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)));
|
2015-04-14 18:36:36 +03:00
|
|
|
return NS_OK;
|
2012-03-22 04:59:12 +04:00
|
|
|
}
|
|
|
|
|
2013-12-15 00:40:55 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendNativeTouchPoint(uint32_t aPointerId,
|
|
|
|
uint32_t aTouchState,
|
|
|
|
int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
|
|
|
double aPressure,
|
2015-04-14 18:36:36 +03:00
|
|
|
uint32_t aOrientation,
|
|
|
|
nsIObserver* aObserver)
|
2013-12-15 00:40:55 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aPressure < 0 || aPressure > 1 || aOrientation > 359) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
NS_DispatchToMainThread(NativeInputRunnable::Create(
|
2017-06-12 22:34:10 +03:00
|
|
|
NewRunnableMethod<uint32_t,
|
|
|
|
nsIWidget::TouchPointerState,
|
|
|
|
LayoutDeviceIntPoint,
|
|
|
|
double,
|
|
|
|
uint32_t,
|
|
|
|
nsIObserver*>("nsIWidget::SynthesizeNativeTouchPoint",
|
|
|
|
widget,
|
|
|
|
&nsIWidget::SynthesizeNativeTouchPoint,
|
|
|
|
aPointerId,
|
|
|
|
(nsIWidget::TouchPointerState)aTouchState,
|
|
|
|
LayoutDeviceIntPoint(aScreenX, aScreenY),
|
|
|
|
aPressure,
|
|
|
|
aOrientation,
|
2017-05-19 10:41:24 +03:00
|
|
|
aObserver)));
|
2015-04-14 18:36:36 +03:00
|
|
|
return NS_OK;
|
2013-12-15 00:40:55 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendNativeTouchTap(int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
2015-04-14 18:36:36 +03:00
|
|
|
bool aLongTap,
|
|
|
|
nsIObserver* aObserver)
|
2013-12-15 00:40:55 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2015-04-14 18:36:36 +03:00
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
NS_DispatchToMainThread(NativeInputRunnable::Create(
|
2017-06-12 22:34:10 +03:00
|
|
|
NewRunnableMethod<LayoutDeviceIntPoint, bool, nsIObserver*>(
|
|
|
|
"nsIWidget::SynthesizeNativeTouchTap",
|
|
|
|
widget,
|
|
|
|
&nsIWidget::SynthesizeNativeTouchTap,
|
|
|
|
LayoutDeviceIntPoint(aScreenX, aScreenY),
|
|
|
|
aLongTap,
|
2017-05-19 10:41:24 +03:00
|
|
|
aObserver)));
|
2015-04-14 18:36:36 +03:00
|
|
|
return NS_OK;
|
2013-12-15 00:40:55 +04:00
|
|
|
}
|
|
|
|
|
2017-06-22 10:27:05 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SuppressAnimation(bool aSuppress)
|
|
|
|
{
|
|
|
|
nsIWidget* widget = GetWidget();
|
|
|
|
if (widget) {
|
|
|
|
widget->SuppressAnimation(aSuppress);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-12-15 00:40:55 +04:00
|
|
|
NS_IMETHODIMP
|
2015-04-14 18:36:36 +03:00
|
|
|
nsDOMWindowUtils::ClearNativeTouchSequence(nsIObserver* aObserver)
|
2013-12-15 00:40:55 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2015-04-14 18:36:36 +03:00
|
|
|
|
2017-05-19 10:41:24 +03:00
|
|
|
NS_DispatchToMainThread(NativeInputRunnable::Create(
|
2017-06-12 22:34:10 +03:00
|
|
|
NewRunnableMethod<nsIObserver*>("nsIWidget::ClearNativeTouchSequence",
|
|
|
|
widget,
|
|
|
|
&nsIWidget::ClearNativeTouchSequence,
|
2017-05-19 10:41:24 +03:00
|
|
|
aObserver)));
|
2015-04-14 18:36:36 +03:00
|
|
|
return NS_OK;
|
2013-12-15 00:40:55 +04:00
|
|
|
}
|
|
|
|
|
2008-06-28 11:55:30 +04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-07-28 08:46:33 +04:00
|
|
|
NS_IMETHODIMP
|
2008-10-30 08:36:01 +03:00
|
|
|
nsDOMWindowUtils::ForceUpdateNativeMenuAt(const nsAString& indexString)
|
2008-07-28 08:46:33 +04:00
|
|
|
{
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2008-10-30 08:36:01 +03:00
|
|
|
return widget->ForceUpdateNativeMenuAt(indexString);
|
2008-07-28 08:46:33 +04:00
|
|
|
}
|
|
|
|
|
2016-07-08 18:35:39 +03:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-02-27 00:14:19 +03:00
|
|
|
nsIWidget*
|
2008-11-27 00:52:42 +03:00
|
|
|
nsDOMWindowUtils::GetWidget(nsPoint* aOffset)
|
2007-02-27 00:14:19 +03:00
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
if (window) {
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2007-02-27 00:14:19 +03:00
|
|
|
if (docShell) {
|
2012-12-29 05:56:42 +04:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2015-04-15 10:08:55 +03:00
|
|
|
return nsContentUtils::GetWidget(presShell, aOffset);
|
2007-02-27 00:14:19 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-30 18:20:58 +04:00
|
|
|
return nullptr;
|
2007-02-27 00:14:19 +03:00
|
|
|
}
|
2007-07-13 02:57:17 +04:00
|
|
|
|
2009-09-23 06:31:37 +04:00
|
|
|
nsIWidget*
|
|
|
|
nsDOMWindowUtils::GetWidgetForElement(nsIDOMElement* aElement)
|
|
|
|
{
|
|
|
|
if (!aElement)
|
|
|
|
return GetWidget();
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
2016-03-31 14:46:32 +03:00
|
|
|
nsIDocument* doc = content->GetUncomposedDoc();
|
2012-07-30 18:20:58 +04:00
|
|
|
nsIPresShell* presShell = doc ? doc->GetShell() : nullptr;
|
2009-09-23 06:31:37 +04:00
|
|
|
|
|
|
|
if (presShell) {
|
2009-12-25 00:20:06 +03:00
|
|
|
nsIFrame* frame = content->GetPrimaryFrame();
|
2009-09-23 06:31:37 +04:00
|
|
|
if (!frame) {
|
|
|
|
frame = presShell->GetRootFrame();
|
|
|
|
}
|
|
|
|
if (frame)
|
2010-07-02 23:11:04 +04:00
|
|
|
return frame->GetNearestWidget();
|
2009-09-23 06:31:37 +04:00
|
|
|
}
|
|
|
|
|
2012-07-30 18:20:58 +04:00
|
|
|
return nullptr;
|
2009-09-23 06:31:37 +04:00
|
|
|
}
|
|
|
|
|
2007-10-20 01:36:20 +04:00
|
|
|
NS_IMETHODIMP
|
2017-07-03 22:53:54 +03:00
|
|
|
nsDOMWindowUtils::GarbageCollect(nsICycleCollectorListener *aListener)
|
2007-10-20 01:36:20 +04:00
|
|
|
{
|
Bug 1375392 - Tweak the PROFILER_LABEL* macros. r=mstange.
This patch makes the following changes to the macros.
- Removes PROFILER_LABEL_FUNC. It's only suitable for use in functions outside
classes, due to PROFILER_FUNCTION_NAME not getting class names, and it was
mostly misused.
- Removes PROFILER_FUNCTION_NAME. It's no longer used, and __func__ is
universally available now anyway.
- Combines the first two string literal arguments of PROFILER_LABEL and
PROFILER_LABEL_DYNAMIC into a single argument. There was no good reason for
them to be separate, and it forced a '::' in the label, which isn't always
appropriate. Also, the meaning of the "name_space" argument was interpreted
in an interesting variety of ways.
- Adds an "AUTO_" prefix to PROFILER_LABEL and PROFILER_LABEL_DYNAMIC, to make
it clearer they construct RAII objects rather than just being function calls.
(I myself have screwed up the scoping because of this in the past.)
- Fills in the 'js::ProfileEntry::Category::' qualifier within the macro, so
the caller doesn't need to. This makes a *lot* more of the uses fit onto a
single line.
The patch also makes the following changes to the macro uses (beyond those
required by the changes described above).
- Fixes a bunch of labels that had gotten out of sync with the name of the
class and/or function that encloses them.
- Removes a useless PROFILER_LABEL use within a trivial scope in
EventStateManager::DispatchMouseOrPointerEvent(). It clearly wasn't serving
any useful purpose. It also serves as extra evidence that the AUTO_ prefix is
a good idea.
- Tweaks DecodePool::SyncRunIf{Preferred,Possible} so that the labelling is
done within them, instead of at their callsites, because that's a more
standard way of doing things.
--HG--
extra : rebase_source : 318d1bc6fc1425a94aacbf489dd46e4f83211de4
2017-06-22 10:08:53 +03:00
|
|
|
AUTO_PROFILER_LABEL("nsDOMWindowUtils::GarbageCollect", GC);
|
2007-10-20 01:36:20 +04:00
|
|
|
|
2013-03-19 14:35:41 +04:00
|
|
|
nsJSContext::GarbageCollectNow(JS::gcreason::DOM_UTILS);
|
2017-07-03 22:53:54 +03:00
|
|
|
nsJSContext::CycleCollectNow(aListener);
|
2007-10-20 01:36:20 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2008-08-28 01:24:03 +04:00
|
|
|
|
2011-07-26 21:11:15 +04:00
|
|
|
NS_IMETHODIMP
|
2017-07-03 22:53:54 +03:00
|
|
|
nsDOMWindowUtils::CycleCollect(nsICycleCollectorListener *aListener)
|
2011-07-26 21:11:15 +04:00
|
|
|
{
|
2017-07-03 22:53:54 +03:00
|
|
|
nsJSContext::CycleCollectNow(aListener);
|
2011-07-26 21:11:15 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2008-08-28 01:24:03 +04:00
|
|
|
|
2014-04-26 00:21:04 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::RunNextCollectorTimer()
|
|
|
|
{
|
2017-09-06 20:18:11 +03:00
|
|
|
nsJSContext::RunNextCollectorTimer(JS::gcreason::DOM_WINDOW_UTILS);
|
2014-04-26 00:21:04 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2008-10-24 00:15:20 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendSimpleGestureEvent(const nsAString& aType,
|
2009-01-03 15:40:26 +03:00
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t aDirection,
|
2012-08-09 11:09:42 +04:00
|
|
|
double aDelta,
|
2012-08-22 19:56:38 +04:00
|
|
|
int32_t aModifiers,
|
|
|
|
uint32_t aClickCount)
|
2008-10-24 00:15:20 +04:00
|
|
|
{
|
|
|
|
// get the widget to send the event to
|
2009-01-03 15:40:26 +03:00
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
2008-10-24 00:15:20 +04:00
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2015-08-26 15:56:59 +03:00
|
|
|
EventMessage msg;
|
2015-09-14 18:14:38 +03:00
|
|
|
if (aType.EqualsLiteral("MozSwipeGestureMayStart")) {
|
|
|
|
msg = eSwipeGestureMayStart;
|
|
|
|
} else if (aType.EqualsLiteral("MozSwipeGestureStart")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eSwipeGestureStart;
|
|
|
|
} else if (aType.EqualsLiteral("MozSwipeGestureUpdate")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eSwipeGestureUpdate;
|
|
|
|
} else if (aType.EqualsLiteral("MozSwipeGestureEnd")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eSwipeGestureEnd;
|
|
|
|
} else if (aType.EqualsLiteral("MozSwipeGesture")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eSwipeGesture;
|
|
|
|
} else if (aType.EqualsLiteral("MozMagnifyGestureStart")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eMagnifyGestureStart;
|
|
|
|
} else if (aType.EqualsLiteral("MozMagnifyGestureUpdate")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eMagnifyGestureUpdate;
|
|
|
|
} else if (aType.EqualsLiteral("MozMagnifyGesture")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eMagnifyGesture;
|
|
|
|
} else if (aType.EqualsLiteral("MozRotateGestureStart")) {
|
2015-09-14 18:14:37 +03:00
|
|
|
msg = eRotateGestureStart;
|
|
|
|
} else if (aType.EqualsLiteral("MozRotateGestureUpdate")) {
|
2015-09-14 18:14:36 +03:00
|
|
|
msg = eRotateGestureUpdate;
|
|
|
|
} else if (aType.EqualsLiteral("MozRotateGesture")) {
|
2015-09-14 18:14:36 +03:00
|
|
|
msg = eRotateGesture;
|
|
|
|
} else if (aType.EqualsLiteral("MozTapGesture")) {
|
2015-09-14 18:14:36 +03:00
|
|
|
msg = eTapGesture;
|
|
|
|
} else if (aType.EqualsLiteral("MozPressTapGesture")) {
|
2015-09-14 18:14:36 +03:00
|
|
|
msg = ePressTapGesture;
|
|
|
|
} else if (aType.EqualsLiteral("MozEdgeUIStarted")) {
|
2015-09-14 18:14:36 +03:00
|
|
|
msg = eEdgeUIStarted;
|
|
|
|
} else if (aType.EqualsLiteral("MozEdgeUICanceled")) {
|
2015-09-14 18:14:36 +03:00
|
|
|
msg = eEdgeUICanceled;
|
|
|
|
} else if (aType.EqualsLiteral("MozEdgeUICompleted")) {
|
2015-09-14 18:14:36 +03:00
|
|
|
msg = eEdgeUICompleted;
|
|
|
|
} else {
|
2008-10-24 00:15:20 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
2015-09-14 18:14:36 +03:00
|
|
|
}
|
|
|
|
|
2014-02-15 05:06:06 +04:00
|
|
|
WidgetSimpleGestureEvent event(true, msg, widget);
|
2016-03-31 11:03:00 +03:00
|
|
|
event.mModifiers = nsContentUtils::GetWidgetModifiers(aModifiers);
|
2016-05-09 22:16:54 +03:00
|
|
|
event.mDirection = aDirection;
|
2016-05-09 22:16:55 +03:00
|
|
|
event.mDelta = aDelta;
|
2016-05-09 22:16:54 +03:00
|
|
|
event.mClickCount = aClickCount;
|
2016-03-28 07:29:42 +03:00
|
|
|
event.mTime = PR_IntervalNow();
|
2008-10-24 00:15:20 +04:00
|
|
|
|
2010-07-19 06:23:48 +04:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2016-04-18 17:09:02 +03:00
|
|
|
event.mRefPoint =
|
|
|
|
nsContentUtils::ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
|
2009-01-03 15:40:26 +03:00
|
|
|
|
2008-10-24 00:15:20 +04:00
|
|
|
nsEventStatus status;
|
|
|
|
return widget->DispatchEvent(&event, status);
|
|
|
|
}
|
2008-11-05 06:58:22 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2010-04-03 15:34:24 +04:00
|
|
|
nsDOMWindowUtils::ElementFromPoint(float aX, float aY,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool aFlushLayout,
|
2008-11-05 06:58:22 +03:00
|
|
|
nsIDOMElement** aReturn)
|
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2008-11-05 06:58:22 +03:00
|
|
|
NS_ENSURE_STATE(doc);
|
2009-03-30 16:19:06 +04:00
|
|
|
|
2012-12-22 12:27:27 +04:00
|
|
|
Element* el =
|
|
|
|
doc->ElementFromPointHelper(aX, aY, aIgnoreRootScrollFrame, aFlushLayout);
|
|
|
|
nsCOMPtr<nsIDOMElement> retval = do_QueryInterface(el);
|
|
|
|
retval.forget(aReturn);
|
|
|
|
return NS_OK;
|
2008-11-05 06:58:22 +03:00
|
|
|
}
|
2008-12-03 04:34:07 +03:00
|
|
|
|
2010-04-08 04:31:26 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::NodesFromRect(float aX, float aY,
|
|
|
|
float aTopSize, float aRightSize,
|
|
|
|
float aBottomSize, float aLeftSize,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool aFlushLayout,
|
2010-04-08 04:31:26 +04:00
|
|
|
nsIDOMNodeList** aReturn)
|
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2010-04-08 04:31:26 +04:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
2015-11-25 07:15:29 +03:00
|
|
|
return doc->NodesFromRectHelper(aX, aY, aTopSize, aRightSize, aBottomSize, aLeftSize,
|
2010-04-08 04:31:26 +04:00
|
|
|
aIgnoreRootScrollFrame, aFlushLayout, aReturn);
|
|
|
|
}
|
|
|
|
|
2014-04-05 07:21:08 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-08-06 17:31:21 +04:00
|
|
|
nsTHashtable<nsPtrHashKey<nsIContent>> translationNodesHash(500);
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<nsTranslationNodeList> list = new nsTranslationNodeList;
|
2014-04-05 07:21:08 +04:00
|
|
|
|
|
|
|
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))) {
|
2015-03-03 14:08:59 +03:00
|
|
|
if (!content->IsHTMLElement()) {
|
2014-04-05 07:21:08 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Skip elements that usually contain non-translatable text content.
|
2015-03-03 14:09:00 +03:00
|
|
|
if (content->IsAnyOfHTMLElements(nsGkAtoms::script,
|
|
|
|
nsGkAtoms::iframe,
|
|
|
|
nsGkAtoms::frameset,
|
|
|
|
nsGkAtoms::frame,
|
|
|
|
nsGkAtoms::code,
|
|
|
|
nsGkAtoms::noscript,
|
|
|
|
nsGkAtoms::style)) {
|
2014-04-05 07:21:08 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-06-17 17:00:52 +03:00
|
|
|
static already_AddRefed<DataSourceSurface>
|
2017-09-28 22:17:07 +03:00
|
|
|
CanvasToDataSourceSurface(HTMLCanvasElement* aCanvas)
|
2008-12-03 04:34:07 +03:00
|
|
|
{
|
2017-09-28 22:17:07 +03:00
|
|
|
MOZ_ASSERT(aCanvas);
|
2010-02-24 22:04:32 +03:00
|
|
|
nsLayoutUtils::SurfaceFromElementResult result =
|
2017-09-28 22:17:07 +03:00
|
|
|
nsLayoutUtils::SurfaceFromElement(aCanvas);
|
2015-11-25 07:15:29 +03:00
|
|
|
|
|
|
|
MOZ_ASSERT(result.GetSourceSurface());
|
|
|
|
return result.GetSourceSurface()->GetDataSurface();
|
2008-12-03 04:34:07 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2017-09-28 22:17:07 +03:00
|
|
|
nsDOMWindowUtils::CompareCanvases(nsISupports *aCanvas1,
|
|
|
|
nsISupports *aCanvas2,
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t* aMaxDifference,
|
|
|
|
uint32_t* retVal)
|
2008-12-03 04:34:07 +03:00
|
|
|
{
|
2012-07-30 18:20:58 +04:00
|
|
|
if (aCanvas1 == nullptr ||
|
|
|
|
aCanvas2 == nullptr ||
|
|
|
|
retVal == nullptr)
|
2008-12-03 04:34:07 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2017-09-28 22:17:07 +03:00
|
|
|
nsCOMPtr<nsIContent> contentCanvas1 = do_QueryInterface(aCanvas1);
|
|
|
|
nsCOMPtr<nsIContent> contentCanvas2 = do_QueryInterface(aCanvas2);
|
2018-03-22 00:39:04 +03:00
|
|
|
auto canvas1 = HTMLCanvasElement::FromNodeOrNull(contentCanvas1);
|
|
|
|
auto canvas2 = HTMLCanvasElement::FromNodeOrNull(contentCanvas2);
|
2017-09-28 22:17:07 +03:00
|
|
|
|
|
|
|
if (!canvas1 || !canvas2) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
RefPtr<DataSourceSurface> img1 = CanvasToDataSourceSurface(canvas1);
|
|
|
|
RefPtr<DataSourceSurface> img2 = CanvasToDataSourceSurface(canvas2);
|
2008-12-03 04:34:07 +03:00
|
|
|
|
2018-01-11 16:48:46 +03:00
|
|
|
if (img1->Equals(img2)) {
|
|
|
|
// They point to the same underlying content.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-06-10 14:01:00 +03:00
|
|
|
DataSourceSurface::ScopedMap map1(img1, DataSourceSurface::READ);
|
|
|
|
DataSourceSurface::ScopedMap map2(img2, DataSourceSurface::READ);
|
|
|
|
|
2012-07-30 18:20:58 +04:00
|
|
|
if (img1 == nullptr || img2 == nullptr ||
|
2015-06-10 14:01:00 +03:00
|
|
|
!map1.IsMapped() || !map2.IsMapped() ||
|
2008-12-03 04:34:07 +03:00
|
|
|
img1->GetSize() != img2->GetSize() ||
|
2015-06-10 14:01:00 +03:00
|
|
|
map1.GetStride() != map2.GetStride()) {
|
2008-12-03 04:34:07 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
2015-06-10 14:01:00 +03:00
|
|
|
}
|
2008-12-03 04:34:07 +03:00
|
|
|
|
|
|
|
int v;
|
2013-12-12 01:05:27 +04:00
|
|
|
IntSize size = img1->GetSize();
|
2015-06-10 14:01:00 +03:00
|
|
|
int32_t stride = map1.GetStride();
|
2008-12-03 04:34:07 +03:00
|
|
|
|
|
|
|
// we can optimize for the common all-pass case
|
2015-06-10 14:01:00 +03:00
|
|
|
if (stride == size.width * 4) {
|
|
|
|
v = memcmp(map1.GetData(), map2.GetData(), size.width * size.height * 4);
|
2008-12-03 04:34:07 +03:00
|
|
|
if (v == 0) {
|
|
|
|
if (aMaxDifference)
|
|
|
|
*aMaxDifference = 0;
|
|
|
|
*retVal = 0;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t dc = 0;
|
|
|
|
uint32_t different = 0;
|
2008-12-03 04:34:07 +03:00
|
|
|
|
|
|
|
for (int j = 0; j < size.height; j++) {
|
2015-06-10 14:01:00 +03:00
|
|
|
unsigned char *p1 = map1.GetData() + j*stride;
|
|
|
|
unsigned char *p2 = map2.GetData() + j*stride;
|
2008-12-03 04:34:07 +03:00
|
|
|
v = memcmp(p1, p2, stride);
|
|
|
|
|
|
|
|
if (v) {
|
|
|
|
for (int i = 0; i < size.width; i++) {
|
2012-08-22 19:56:38 +04:00
|
|
|
if (*(uint32_t*) p1 != *(uint32_t*) p2) {
|
2008-12-03 04:34:07 +03:00
|
|
|
|
|
|
|
different++;
|
|
|
|
|
2013-01-15 16:22:03 +04:00
|
|
|
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);
|
2008-12-03 04:34:07 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
p1 += 4;
|
|
|
|
p2 += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aMaxDifference)
|
|
|
|
*aMaxDifference = dc;
|
|
|
|
|
|
|
|
*retVal = different;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-01-06 04:15:13 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsDOMWindowUtils::GetIsMozAfterPaintPending(bool *aResult)
|
2009-01-06 04:15:13 +03:00
|
|
|
{
|
2012-09-10 23:45:10 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
2011-10-17 18:59:28 +04:00
|
|
|
*aResult = false;
|
2009-01-06 04:15:13 +03:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext)
|
|
|
|
return NS_OK;
|
|
|
|
*aResult = presContext->IsDOMPaintEventPending();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-02-12 13:44:38 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsDOMWindowUtils::DisableNonTestMouseEvents(bool aDisable)
|
2009-02-12 13:44:38 +03:00
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2009-02-12 13:44:38 +03:00
|
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
2012-12-29 05:56:42 +04:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2009-02-12 13:44:38 +03:00
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
2010-03-31 16:45:32 +04:00
|
|
|
presShell->DisableNonTestMouseEvents(aDisable);
|
|
|
|
return NS_OK;
|
2009-02-12 13:44:38 +03:00
|
|
|
}
|
2009-03-03 23:11:14 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsDOMWindowUtils::SuppressEventHandling(bool aSuppress)
|
2009-03-03 23:11:14 +03:00
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2009-03-03 23:11:14 +03:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
if (aSuppress) {
|
2017-02-22 09:00:00 +03:00
|
|
|
doc->SuppressEventHandling();
|
2009-03-03 23:11:14 +03:00
|
|
|
} else {
|
2017-02-22 09:00:00 +03:00
|
|
|
doc->UnsuppressEventHandlingAndFireEvents(true);
|
2009-03-03 23:11:14 +03:00
|
|
|
}
|
2009-03-30 16:19:06 +04:00
|
|
|
|
2009-03-03 23:11:14 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-09-11 02:21:04 +04:00
|
|
|
static nsresult
|
2016-11-15 01:15:46 +03:00
|
|
|
getScrollXYAppUnits(const nsWeakPtr& aWindow, bool aFlushLayout, nsPoint& aScrollPos) {
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(aWindow);
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = window ? window->GetExtantDoc() : nullptr;
|
2009-03-30 16:19:06 +04:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
if (aFlushLayout) {
|
2017-01-05 10:31:56 +03:00
|
|
|
doc->FlushPendingNotifications(FlushType::Layout);
|
2009-03-30 16:19:06 +04:00
|
|
|
}
|
|
|
|
|
2010-06-25 17:59:57 +04:00
|
|
|
nsIPresShell *presShell = doc->GetShell();
|
2009-03-30 16:19:06 +04:00
|
|
|
if (presShell) {
|
2009-09-03 07:57:46 +04:00
|
|
|
nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable();
|
|
|
|
if (sf) {
|
2013-09-11 02:21:04 +04:00
|
|
|
aScrollPos = sf->GetScrollPosition();
|
2009-03-30 16:19:06 +04:00
|
|
|
}
|
|
|
|
}
|
2013-09-11 02:21:04 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-03-30 16:19:06 +04:00
|
|
|
|
2013-09-11 02:21:04 +04:00
|
|
|
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);
|
2009-09-03 07:57:46 +04:00
|
|
|
*aScrollX = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.x);
|
|
|
|
*aScrollY = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.y);
|
2009-03-30 16:19:06 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-05-05 10:15:23 +04:00
|
|
|
|
2013-09-11 02:21:04 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-02-14 00:32:35 +04:00
|
|
|
NS_IMETHODIMP
|
2013-02-26 02:13:36 +04:00
|
|
|
nsDOMWindowUtils::GetScrollbarSize(bool aFlushLayout, int32_t* aWidth,
|
|
|
|
int32_t* aHeight)
|
2013-02-14 00:32:35 +04:00
|
|
|
{
|
2013-02-26 02:13:36 +04:00
|
|
|
*aWidth = 0;
|
|
|
|
*aHeight = 0;
|
2013-02-14 00:32:35 +04:00
|
|
|
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-02-14 00:32:35 +04:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
if (aFlushLayout) {
|
2017-01-05 10:31:56 +03:00
|
|
|
doc->FlushPendingNotifications(FlushType::Layout);
|
2013-02-14 00:32:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
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();
|
2013-02-26 02:13:36 +04:00
|
|
|
*aWidth = nsPresContext::AppUnitsToIntCSSPixels(sizes.LeftRight());
|
|
|
|
*aHeight = nsPresContext::AppUnitsToIntCSSPixels(sizes.TopBottom());
|
2013-02-14 00:32:35 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-06-04 10:06:29 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetBoundsWithoutFlushing(nsIDOMElement *aElement,
|
2018-03-13 16:19:17 +03:00
|
|
|
nsISupports** aResult)
|
2013-06-04 10:06:29 +04:00
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2013-06-04 10:06:29 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<DOMRect> rect = new DOMRect(window);
|
2013-06-04 10:06:29 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-07-25 06:07:39 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-05-23 18:49:59 +04:00
|
|
|
NS_IMETHODIMP
|
2018-03-13 16:19:17 +03:00
|
|
|
nsDOMWindowUtils::GetRootBounds(nsISupports** aResult)
|
2012-05-23 18:49:59 +04:00
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsIDocument* doc = GetDocument();
|
2012-05-23 18:49:59 +04:00
|
|
|
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();
|
2017-08-14 15:30:10 +03:00
|
|
|
bounds.SetWidth(bounds.Width() + sf->GetScrollPortRect().Width());
|
|
|
|
bounds.SetHeight(bounds.Height() + sf->GetScrollPortRect().Height());
|
2012-05-23 18:49:59 +04:00
|
|
|
} else if (presShell->GetRootFrame()) {
|
|
|
|
bounds = presShell->GetRootFrame()->GetRect();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<DOMRect> rect = new DOMRect(window);
|
2018-02-19 23:15:23 +03:00
|
|
|
rect->SetRect(nsPresContext::AppUnitsToFloatCSSPixels(bounds.x),
|
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(bounds.y),
|
2017-08-14 15:30:10 +03:00
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(bounds.Width()),
|
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(bounds.Height()));
|
2013-03-17 11:55:17 +04:00
|
|
|
rect.forget(aResult);
|
2012-05-23 18:49:59 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-05-05 10:15:23 +04:00
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsDOMWindowUtils::GetIMEIsOpen(bool *aState)
|
2009-05-05 10:15:23 +04:00
|
|
|
{
|
|
|
|
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.
|
2011-11-27 15:51:52 +04:00
|
|
|
InputContext context = widget->GetInputContext();
|
2011-11-27 15:51:53 +04:00
|
|
|
if (context.mIMEState.mEnabled != IMEState::ENABLED) {
|
2009-05-05 10:15:23 +04:00
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
2011-11-27 15:51:52 +04:00
|
|
|
}
|
2009-05-05 10:15:23 +04:00
|
|
|
|
2011-11-27 15:51:53 +04:00
|
|
|
if (context.mIMEState.mOpen == IMEState::OPEN_STATE_NOT_SUPPORTED) {
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
*aState = (context.mIMEState.mOpen == IMEState::OPEN);
|
|
|
|
return NS_OK;
|
2009-05-05 10:15:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::GetIMEStatus(uint32_t *aState)
|
2009-05-05 10:15:23 +04:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aState);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2011-11-27 15:51:52 +04:00
|
|
|
InputContext context = widget->GetInputContext();
|
2012-08-22 19:56:38 +04:00
|
|
|
*aState = static_cast<uint32_t>(context.mIMEState.mEnabled);
|
2010-11-23 09:48:45 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2018-02-07 09:16:41 +03:00
|
|
|
nsDOMWindowUtils::GetFocusedInputType(nsAString& aType)
|
2010-11-23 09:48:45 +03:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2018-02-07 09:16:41 +03:00
|
|
|
aType = widget->GetInputContext().mHTMLInputType;
|
2010-11-23 09:48:45 +03:00
|
|
|
return NS_OK;
|
2009-05-05 10:15:23 +04:00
|
|
|
}
|
|
|
|
|
2013-08-08 23:56:09 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-08-04 01:41:36 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetScreenPixelsPerCSSPixel(float* aScreenPixels)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-08-23 00:17:26 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
2016-12-22 22:05:54 +03:00
|
|
|
*aScreenPixels = window->GetDevicePixelRatio(CallerType::System);
|
|
|
|
return NS_OK;
|
2009-08-04 01:41:36 +04:00
|
|
|
}
|
2009-10-17 02:19:01 +04:00
|
|
|
|
2012-09-29 15:35:19 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetFullZoom(float* aFullZoom)
|
|
|
|
{
|
|
|
|
*aFullZoom = 1.0f;
|
|
|
|
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-11-10 05:47:55 +03:00
|
|
|
*aFullZoom = presContext->DeviceContext()->GetFullZoom();
|
2012-09-29 15:35:19 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2015-11-25 07:15:29 +03:00
|
|
|
|
2009-10-29 14:11:02 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::DispatchDOMEventViaPresShell(nsIDOMNode* aTarget,
|
|
|
|
nsIDOMEvent* aEvent,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aTrusted,
|
|
|
|
bool* aRetVal)
|
2009-10-29 14:11:02 +03:00
|
|
|
{
|
2012-06-11 03:44:50 +04:00
|
|
|
NS_ENSURE_STATE(aEvent);
|
|
|
|
aEvent->SetTrusted(aTrusted);
|
2016-02-12 18:40:07 +03:00
|
|
|
WidgetEvent* internalEvent = aEvent->WidgetEventPtr();
|
2009-10-29 14:11:02 +03:00
|
|
|
NS_ENSURE_STATE(internalEvent);
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aTarget);
|
|
|
|
NS_ENSURE_STATE(content);
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2013-03-08 15:04:53 +04:00
|
|
|
if (content->OwnerDoc()->GetWindow() != window) {
|
|
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
|
|
}
|
2016-03-31 14:46:32 +03:00
|
|
|
nsCOMPtr<nsIDocument> targetDoc = content->GetUncomposedDoc();
|
2013-03-08 15:04:53 +04:00
|
|
|
NS_ENSURE_STATE(targetDoc);
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<nsIPresShell> targetShell = targetDoc->GetShell();
|
2013-03-08 15:04:53 +04:00
|
|
|
NS_ENSURE_STATE(targetShell);
|
2009-10-29 14:11:02 +03:00
|
|
|
|
2017-01-05 10:31:56 +03:00
|
|
|
targetDoc->FlushPendingNotifications(FlushType::Layout);
|
2013-07-04 14:56:22 +04:00
|
|
|
|
2009-10-29 14:11:02 +03:00
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
2013-03-08 15:04:53 +04:00
|
|
|
targetShell->HandleEventWithTarget(internalEvent, nullptr, content, &status);
|
2009-10-29 14:11:02 +03:00
|
|
|
*aRetVal = (status != nsEventStatus_eConsumeNoDefault);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-12-15 00:58:50 +03:00
|
|
|
|
2010-03-19 08:02:53 +03:00
|
|
|
static void
|
2013-10-02 07:46:03 +04:00
|
|
|
InitEvent(WidgetGUIEvent& aEvent, LayoutDeviceIntPoint* aPt = nullptr)
|
2010-03-19 08:02:53 +03:00
|
|
|
{
|
|
|
|
if (aPt) {
|
2016-04-18 17:09:02 +03:00
|
|
|
aEvent.mRefPoint = *aPt;
|
2010-03-19 08:02:53 +03:00
|
|
|
}
|
2016-03-28 07:29:42 +03:00
|
|
|
aEvent.mTime = PR_IntervalNow();
|
2010-03-19 08:02:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::SendQueryContentEvent(uint32_t aType,
|
2016-06-16 08:10:49 +03:00
|
|
|
int64_t aOffset, uint32_t aLength,
|
2012-08-22 19:56:38 +04:00
|
|
|
int32_t aX, int32_t aY,
|
2014-04-26 03:52:13 +04:00
|
|
|
uint32_t aAdditionalFlags,
|
2010-03-19 08:02:53 +03:00
|
|
|
nsIQueryContentEventResult **aResult)
|
|
|
|
{
|
2012-07-30 18:20:58 +04:00
|
|
|
*aResult = nullptr;
|
2010-03-19 08:02:53 +03:00
|
|
|
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
2010-07-27 17:38:03 +04:00
|
|
|
|
2012-04-02 06:23:51 +04:00
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2010-07-27 17:38:03 +04:00
|
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
|
2012-12-29 05:56:42 +04:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2010-07-27 17:38:03 +04:00
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsPresContext* presContext = presShell->GetPresContext();
|
|
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
|
|
|
|
2010-03-19 08:02:53 +03:00
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2015-08-26 15:56:59 +03:00
|
|
|
EventMessage message;
|
|
|
|
switch (aType) {
|
|
|
|
case QUERY_SELECTED_TEXT:
|
2015-09-10 04:40:05 +03:00
|
|
|
message = eQuerySelectedText;
|
2015-08-26 15:56:59 +03:00
|
|
|
break;
|
|
|
|
case QUERY_TEXT_CONTENT:
|
2015-09-10 04:40:05 +03:00
|
|
|
message = eQueryTextContent;
|
2015-08-26 15:56:59 +03:00
|
|
|
break;
|
|
|
|
case QUERY_CARET_RECT:
|
2015-09-10 04:40:06 +03:00
|
|
|
message = eQueryCaretRect;
|
2015-08-26 15:56:59 +03:00
|
|
|
break;
|
|
|
|
case QUERY_TEXT_RECT:
|
2015-09-11 15:21:26 +03:00
|
|
|
message = eQueryTextRect;
|
2015-08-26 15:56:59 +03:00
|
|
|
break;
|
|
|
|
case QUERY_EDITOR_RECT:
|
2015-09-10 04:40:06 +03:00
|
|
|
message = eQueryEditorRect;
|
2015-08-26 15:56:59 +03:00
|
|
|
break;
|
|
|
|
case QUERY_CHARACTER_AT_POINT:
|
2015-09-10 04:40:06 +03:00
|
|
|
message = eQueryCharacterAtPoint;
|
2015-08-26 15:56:59 +03:00
|
|
|
break;
|
2016-06-23 12:42:00 +03:00
|
|
|
case QUERY_TEXT_RECT_ARRAY:
|
|
|
|
message = eQueryTextRectArray;
|
|
|
|
break;
|
2015-08-26 15:56:59 +03:00
|
|
|
default:
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
2010-03-19 08:02:53 +03:00
|
|
|
}
|
|
|
|
|
2016-06-20 10:31:29 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-03-19 08:02:53 +03:00
|
|
|
nsCOMPtr<nsIWidget> targetWidget = widget;
|
2013-08-02 11:05:16 +04:00
|
|
|
LayoutDeviceIntPoint pt(aX, aY);
|
2010-03-19 08:02:53 +03:00
|
|
|
|
2016-06-16 08:10:49 +03:00
|
|
|
WidgetQueryContentEvent::Options options;
|
|
|
|
options.mUseNativeLineBreak =
|
2014-04-26 03:52:13 +04:00
|
|
|
!(aAdditionalFlags & QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK);
|
2016-06-16 08:10:49 +03:00
|
|
|
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;
|
|
|
|
}
|
2014-04-26 03:52:13 +04:00
|
|
|
|
2015-09-10 04:40:06 +03:00
|
|
|
if (message == eQueryCharacterAtPoint) {
|
2010-03-19 08:02:53 +03:00
|
|
|
// Looking for the widget at the point.
|
2015-09-10 04:40:06 +03:00
|
|
|
WidgetQueryContentEvent dummyEvent(true, eQueryContentState, widget);
|
2016-06-16 08:10:49 +03:00
|
|
|
dummyEvent.Init(options);
|
2010-03-19 08:02:53 +03:00
|
|
|
InitEvent(dummyEvent, &pt);
|
|
|
|
nsIFrame* popupFrame =
|
2010-07-27 17:38:03 +04:00
|
|
|
nsLayoutUtils::GetPopupFrameForEventCoordinates(presContext->GetRootPresContext(), &dummyEvent);
|
2010-03-19 08:02:53 +03:00
|
|
|
|
2016-08-19 02:03:04 +03:00
|
|
|
LayoutDeviceIntRect widgetBounds = widget->GetClientBounds();
|
2011-12-02 01:35:42 +04:00
|
|
|
widgetBounds.MoveTo(0, 0);
|
2010-03-19 08:02:53 +03:00
|
|
|
|
|
|
|
// There is no popup frame at the point and the point isn't in our widget,
|
|
|
|
// we cannot process this request.
|
2015-11-10 08:37:32 +03:00
|
|
|
NS_ENSURE_TRUE(popupFrame || widgetBounds.Contains(pt), NS_ERROR_FAILURE);
|
2010-03-19 08:02:53 +03:00
|
|
|
|
|
|
|
// Fire the event on the widget at the point
|
|
|
|
if (popupFrame) {
|
2010-07-02 23:11:04 +04:00
|
|
|
targetWidget = popupFrame->GetNearestWidget();
|
2010-03-19 08:02:53 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-04 23:21:03 +03:00
|
|
|
pt += widget->WidgetToScreenOffset() - targetWidget->WidgetToScreenOffset();
|
2010-03-19 08:02:53 +03:00
|
|
|
|
2015-08-26 15:56:59 +03:00
|
|
|
WidgetQueryContentEvent queryEvent(true, message, targetWidget);
|
2010-03-19 08:02:53 +03:00
|
|
|
InitEvent(queryEvent, &pt);
|
|
|
|
|
2015-08-26 15:56:59 +03:00
|
|
|
switch (message) {
|
2015-09-10 04:40:05 +03:00
|
|
|
case eQueryTextContent:
|
2016-06-16 08:10:49 +03:00
|
|
|
queryEvent.InitForQueryTextContent(aOffset, aLength, options);
|
2010-03-19 08:02:53 +03:00
|
|
|
break;
|
2015-09-10 04:40:06 +03:00
|
|
|
case eQueryCaretRect:
|
2016-06-16 08:10:49 +03:00
|
|
|
queryEvent.InitForQueryCaretRect(aOffset, options);
|
2010-03-19 08:02:53 +03:00
|
|
|
break;
|
2015-09-11 15:21:26 +03:00
|
|
|
case eQueryTextRect:
|
2016-06-16 08:10:49 +03:00
|
|
|
queryEvent.InitForQueryTextRect(aOffset, aLength, options);
|
2014-04-26 03:52:13 +04:00
|
|
|
break;
|
2016-06-20 10:31:29 +03:00
|
|
|
case eQuerySelectedText:
|
2016-06-16 08:10:49 +03:00
|
|
|
queryEvent.InitForQuerySelectedText(selectionType, options);
|
2016-06-20 10:31:29 +03:00
|
|
|
break;
|
2016-06-23 12:42:00 +03:00
|
|
|
case eQueryTextRectArray:
|
|
|
|
queryEvent.InitForQueryTextRectArray(aOffset, aLength, options);
|
|
|
|
break;
|
2014-04-26 03:52:13 +04:00
|
|
|
default:
|
2016-06-16 08:10:49 +03:00
|
|
|
queryEvent.Init(options);
|
2010-03-19 08:02:53 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsEventStatus status;
|
|
|
|
nsresult rv = targetWidget->DispatchEvent(&queryEvent, status);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2016-11-14 12:35:58 +03:00
|
|
|
auto* result = new nsQueryContentEventResult();
|
2010-03-19 08:02:53 +03:00
|
|
|
result->SetEventResult(widget, queryEvent);
|
|
|
|
NS_ADDREF(*aResult = result);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::SendSelectionSetEvent(uint32_t aOffset,
|
|
|
|
uint32_t aLength,
|
2014-04-26 03:52:13 +04:00
|
|
|
uint32_t aAdditionalFlags,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool *aResult)
|
2010-03-19 08:02:53 +03:00
|
|
|
{
|
2011-10-17 18:59:28 +04:00
|
|
|
*aResult = false;
|
2010-03-19 08:02:53 +03:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2015-09-08 17:33:38 +03:00
|
|
|
WidgetSelectionEvent selectionEvent(true, eSetSelection, widget);
|
2010-03-19 08:02:53 +03:00
|
|
|
InitEvent(selectionEvent);
|
|
|
|
|
|
|
|
selectionEvent.mOffset = aOffset;
|
|
|
|
selectionEvent.mLength = aLength;
|
2014-04-26 03:52:13 +04:00
|
|
|
selectionEvent.mReversed = (aAdditionalFlags & SELECTION_SET_FLAG_REVERSE);
|
|
|
|
selectionEvent.mUseNativeLineBreak =
|
|
|
|
!(aAdditionalFlags & SELECTION_SET_FLAG_USE_XP_LINE_BREAK);
|
2010-03-19 08:02:53 +03:00
|
|
|
|
|
|
|
nsEventStatus status;
|
|
|
|
nsresult rv = widget->DispatchEvent(&selectionEvent, status);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
*aResult = selectionEvent.mSucceeded;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-12-15 00:58:50 +03:00
|
|
|
NS_IMETHODIMP
|
2010-01-11 04:45:45 +03:00
|
|
|
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;
|
|
|
|
|
2015-08-26 15:56:59 +03:00
|
|
|
EventMessage msg;
|
2015-09-10 19:59:53 +03:00
|
|
|
if (aType.EqualsLiteral("cut")) {
|
2015-09-10 19:59:52 +03:00
|
|
|
msg = eContentCommandCut;
|
2015-09-10 19:59:53 +03:00
|
|
|
} else if (aType.EqualsLiteral("copy")) {
|
2015-09-10 19:59:52 +03:00
|
|
|
msg = eContentCommandCopy;
|
2015-09-10 19:59:53 +03:00
|
|
|
} else if (aType.EqualsLiteral("paste")) {
|
2015-09-10 19:59:52 +03:00
|
|
|
msg = eContentCommandPaste;
|
2015-09-10 19:59:53 +03:00
|
|
|
} else if (aType.EqualsLiteral("delete")) {
|
2015-09-10 19:59:52 +03:00
|
|
|
msg = eContentCommandDelete;
|
2015-09-10 19:59:53 +03:00
|
|
|
} else if (aType.EqualsLiteral("undo")) {
|
2015-09-10 19:59:53 +03:00
|
|
|
msg = eContentCommandUndo;
|
2015-09-10 19:59:53 +03:00
|
|
|
} else if (aType.EqualsLiteral("redo")) {
|
|
|
|
msg = eContentCommandRedo;
|
|
|
|
} else if (aType.EqualsLiteral("pasteTransferable")) {
|
2015-09-10 19:59:52 +03:00
|
|
|
msg = eContentCommandPasteTransferable;
|
2015-09-10 19:59:53 +03:00
|
|
|
} else {
|
2010-01-11 04:45:45 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
2015-09-10 19:59:53 +03:00
|
|
|
}
|
2013-05-28 03:47:45 +04:00
|
|
|
|
2013-09-27 10:20:54 +04:00
|
|
|
WidgetContentCommandEvent event(true, msg, widget);
|
2015-09-10 19:59:52 +03:00
|
|
|
if (msg == eContentCommandPasteTransferable) {
|
2010-01-11 04:45:45 +03:00
|
|
|
event.mTransferable = aTransferable;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsEventStatus status;
|
|
|
|
return widget->DispatchEvent(&event, status);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-09 21:39:36 +04:00
|
|
|
nsDOMWindowUtils::GetClassName(JS::Handle<JS::Value> aObject, JSContext* aCx,
|
|
|
|
char** aName)
|
2009-12-15 00:58:50 +03:00
|
|
|
{
|
|
|
|
// Our argument must be a non-null object.
|
2014-04-28 07:27:54 +04:00
|
|
|
if (aObject.isPrimitive()) {
|
2009-12-15 00:58:50 +03:00
|
|
|
return NS_ERROR_XPC_BAD_CONVERT_JS;
|
2011-12-04 01:50:16 +04:00
|
|
|
}
|
2009-12-15 00:58:50 +03:00
|
|
|
|
2014-04-28 06:58:52 +04:00
|
|
|
*aName = NS_strdup(JS_GetClass(aObject.toObjectOrNull())->name);
|
2015-02-10 01:34:50 +03:00
|
|
|
MOZ_ASSERT(*aName, "NS_strdup should be infallible.");
|
2011-12-04 01:50:16 +04:00
|
|
|
return NS_OK;
|
2009-12-15 00:58:50 +03:00
|
|
|
}
|
2010-04-03 05:58:25 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetVisitedDependentComputedStyle(
|
|
|
|
nsIDOMElement *aElement, const nsAString& aPseudoElement,
|
|
|
|
const nsAString& aPropertyName, nsAString& aResult)
|
|
|
|
{
|
|
|
|
aResult.Truncate();
|
|
|
|
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2015-10-27 00:37:32 +03:00
|
|
|
nsCOMPtr<Element> element = do_QueryInterface(aElement);
|
|
|
|
NS_ENSURE_STATE(window && element);
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowInner> innerWindow = window->GetCurrentInnerWindow();
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2018-01-11 11:17:57 +03:00
|
|
|
nsCOMPtr<nsICSSDeclaration> decl;
|
2015-10-27 00:37:32 +03:00
|
|
|
{
|
|
|
|
ErrorResult rv;
|
2016-01-30 20:05:36 +03:00
|
|
|
decl = innerWindow->GetComputedStyle(*element, aPseudoElement, rv);
|
2015-10-27 00:37:32 +03:00
|
|
|
ENSURE_SUCCESS(rv, rv.StealNSResult());
|
|
|
|
}
|
2010-04-03 05:58:25 +04:00
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(true);
|
2015-10-27 00:37:32 +03:00
|
|
|
nsresult rv = decl->GetPropertyValue(aPropertyName, aResult);
|
2011-10-17 18:59:28 +04:00
|
|
|
static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(false);
|
2010-04-03 05:58:25 +04:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
2010-04-12 00:51:00 +04:00
|
|
|
|
2010-07-02 01:53:00 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::EnterModalState()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
window->EnterModalState();
|
2010-07-02 01:53:00 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::LeaveModalState()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2013-08-12 23:54:51 +04:00
|
|
|
window->LeaveModalState();
|
2010-07-02 01:53:00 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsDOMWindowUtils::IsInModalState(bool *retval)
|
2010-07-02 01:53:00 +04:00
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2017-11-04 01:25:38 +03:00
|
|
|
*retval = nsGlobalWindowOuter::Cast(window)->IsInModalState();
|
2010-07-02 01:53:00 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-03-12 19:14:55 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetDesktopModeViewport(bool aDesktopMode)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2015-03-12 19:14:55 +03:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2016-01-30 20:05:36 +03:00
|
|
|
window->SetDesktopModeViewport(aDesktopMode);
|
2015-03-12 19:14:55 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-05-11 05:12:35 +04:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::GetOuterWindowID(uint64_t *aWindowID)
|
2010-05-11 05:12:35 +04:00
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
*aWindowID = window->WindowID();
|
2010-05-11 05:12:35 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::GetCurrentInnerWindowID(uint64_t *aWindowID)
|
2010-05-11 05:12:35 +04:00
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_NOT_AVAILABLE);
|
|
|
|
|
2017-11-04 01:25:38 +03:00
|
|
|
nsGlobalWindowInner* inner =
|
|
|
|
nsGlobalWindowOuter::Cast(window)->GetCurrentInnerWindowInternal();
|
2010-05-11 05:12:35 +04:00
|
|
|
if (!inner) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
2010-10-21 04:24:15 +04:00
|
|
|
*aWindowID = inner->WindowID();
|
2010-05-11 05:12:35 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-07-23 01:33:37 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SuspendTimeouts()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
2016-10-26 20:20:15 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowInner> inner = window->GetCurrentInnerWindow();
|
|
|
|
NS_ENSURE_TRUE(inner, NS_ERROR_FAILURE);
|
|
|
|
|
2016-10-26 20:20:16 +03:00
|
|
|
inner->Suspend();
|
2010-07-23 01:33:37 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::ResumeTimeouts()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
2016-10-26 20:20:15 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowInner> inner = window->GetCurrentInnerWindow();
|
|
|
|
NS_ENSURE_TRUE(inner, NS_ERROR_FAILURE);
|
|
|
|
|
2016-10-26 20:20:16 +03:00
|
|
|
inner->Resume();
|
2010-07-23 01:33:37 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-09-03 22:01:05 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetLayerManagerType(nsAString& aType)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-03-15 08:41:52 +04:00
|
|
|
LayerManager *mgr = widget->GetLayerManager(nsIWidget::LAYER_MANAGER_PERSISTENT);
|
2010-09-03 22:01:05 +04:00
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
mgr->GetBackendName(aType);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-09-17 04:43:23 +04:00
|
|
|
|
Bug 825928: Land layers refactoring. r=jrmuizel,bas,nical,mattwoodrow,roc,nrc,benwa,bjacob,jgilbert,kchen CLOSED TREE
Please contact Bas Schouten <bschouten@mozilla.com>, Nicolas Silva <nsilva@mozilla.com> or Nicholas Cameron <ncameron@mozilla.com> with general questions. Below is a rough list of authors to contact with specific questions.
Authors:
gfx/layers/Compositor.* gfx/layers/Effects.h - Compositor Interface - bas,nrc,nical
gfx/layers/d3d* - D3D9/D3D10 - bas
gfx/layers/ThebesLayer* - ThebesLayers - nrc,bas
gfx/layers/composite/* - CompositeLayers - nrc,nical
gfx/layers/client/* - Client - nrc,nical,bas
gfx/layers/*Image* - nical
gfx/layers/ipc ipc - IPC - nical
gfx/layers/opengl - CompositorOGL - nrc,nical
gfx/2d - bas,nrc
gfx/gl - GLContext - bjacob
dom/* layout/* - DOM - mattwoodrow
2013-04-10 13:20:52 +04:00
|
|
|
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;
|
|
|
|
|
2016-12-04 11:35:33 +03:00
|
|
|
*retval = !!mgr->AsKnowsCompositor();
|
Bug 825928: Land layers refactoring. r=jrmuizel,bas,nical,mattwoodrow,roc,nrc,benwa,bjacob,jgilbert,kchen CLOSED TREE
Please contact Bas Schouten <bschouten@mozilla.com>, Nicolas Silva <nsilva@mozilla.com> or Nicholas Cameron <ncameron@mozilla.com> with general questions. Below is a rough list of authors to contact with specific questions.
Authors:
gfx/layers/Compositor.* gfx/layers/Effects.h - Compositor Interface - bas,nrc,nical
gfx/layers/d3d* - D3D9/D3D10 - bas
gfx/layers/ThebesLayer* - ThebesLayers - nrc,bas
gfx/layers/composite/* - CompositeLayers - nrc,nical
gfx/layers/client/* - Client - nrc,nical,bas
gfx/layers/*Image* - nical
gfx/layers/ipc ipc - IPC - nical
gfx/layers/opengl - CompositorOGL - nrc,nical
gfx/2d - bas,nrc
gfx/gl - GLContext - bjacob
dom/* layout/* - DOM - mattwoodrow
2013-04-10 13:20:52 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2017-06-24 00:23:13 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-12-21 17:25:07 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsWebRenderRequested(bool* retval)
|
|
|
|
{
|
|
|
|
*retval = gfxPlatform::WebRenderPrefEnabled() ||
|
|
|
|
gfxPlatform::WebRenderEnvvarEnabled();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-07-26 01:50:14 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetCurrentAudioBackend(nsAString& aBackend)
|
|
|
|
{
|
|
|
|
CubebUtils::GetCurrentBackend(aBackend);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2017-07-18 11:09:10 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetCurrentMaxAudioChannels(uint32_t* aChannels)
|
|
|
|
{
|
|
|
|
*aChannels = CubebUtils::MaxNumberOfChannels();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetCurrentPreferredSampleRate(uint32_t* aRate)
|
|
|
|
{
|
|
|
|
*aRate = CubebUtils::PreferredSampleRate();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::AudioDevices(uint16_t aSide, nsIArray** aDevices)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aDevices);
|
|
|
|
NS_ENSURE_ARG((aSide == AUDIO_INPUT) || (aSide == AUDIO_OUTPUT));
|
|
|
|
*aDevices = nullptr;
|
|
|
|
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsCOMPtr<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) {
|
2017-10-21 17:53:02 +03:00
|
|
|
devices->AppendElement(device);
|
2017-07-18 11:09:10 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
devices.forget(aDevices);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-01-06 02:40:35 +04:00
|
|
|
NS_IMETHODIMP
|
2013-01-23 22:47:44 +04:00
|
|
|
nsDOMWindowUtils::StartFrameTimeRecording(uint32_t *startIndex)
|
2012-01-06 02:40:35 +04:00
|
|
|
{
|
2013-01-23 22:47:44 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(startIndex);
|
|
|
|
|
2012-01-06 02:40:35 +04:00
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
LayerManager *mgr = widget->GetLayerManager();
|
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-11-27 11:32:19 +04:00
|
|
|
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);
|
2012-01-06 02:40:35 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2013-01-23 22:47:44 +04:00
|
|
|
nsDOMWindowUtils::StopFrameTimeRecording(uint32_t startIndex,
|
|
|
|
uint32_t *frameCount,
|
|
|
|
float **frameIntervals)
|
2012-01-06 02:40:35 +04:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(frameCount);
|
2013-01-04 06:53:15 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(frameIntervals);
|
2012-01-06 02:40:35 +04:00
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
LayerManager *mgr = widget->GetLayerManager();
|
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-01-04 06:53:15 +04:00
|
|
|
nsTArray<float> tmpFrameIntervals;
|
2013-11-27 11:32:19 +04:00
|
|
|
mgr->StopFrameTimeRecording(startIndex, tmpFrameIntervals);
|
2013-01-04 06:53:15 +04:00
|
|
|
*frameCount = tmpFrameIntervals.Length();
|
2012-01-06 02:40:35 +04:00
|
|
|
|
2015-03-27 03:01:12 +03:00
|
|
|
*frameIntervals = (float*)moz_xmalloc(*frameCount * sizeof(float));
|
2012-01-06 02:40:35 +04:00
|
|
|
|
2013-01-23 22:47:44 +04:00
|
|
|
/* 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];
|
2012-01-06 02:40:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-04-12 10:18:43 +04:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::AdvanceTimeAndRefresh(int64_t aMilliseconds)
|
2011-04-12 10:18:43 +04:00
|
|
|
{
|
2014-12-22 03:35:42 +03:00
|
|
|
// 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
|
2015-04-21 04:22:09 +03:00
|
|
|
// 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.
|
2014-12-22 03:35:42 +03:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
|
|
|
if (doc) {
|
2015-04-21 04:22:09 +03:00
|
|
|
PendingAnimationTracker* tracker = doc->GetPendingAnimationTracker();
|
2014-12-22 03:35:42 +03:00
|
|
|
if (tracker) {
|
2015-04-21 04:22:09 +03:00
|
|
|
tracker->TriggerPendingAnimationsNow();
|
2014-12-22 03:35:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-21 21:09:03 +03:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
|
|
|
nsRefreshDriver* driver = presContext->RefreshDriver();
|
|
|
|
driver->AdvanceTimeAndRefresh(aMilliseconds);
|
2014-02-12 08:41:57 +04:00
|
|
|
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<LayerTransactionChild> transaction = GetLayerTransaction();
|
2015-04-21 21:09:03 +03:00
|
|
|
if (transaction && transaction->IPCOpen()) {
|
|
|
|
transaction->SendSetTestSampleTime(driver->MostRecentRefresh());
|
2017-06-28 03:29:06 +03:00
|
|
|
} else if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) {
|
|
|
|
wrbc->SendSetTestSampleTime(driver->MostRecentRefresh());
|
2015-04-21 21:09:03 +03:00
|
|
|
}
|
2014-02-12 08:41:57 +04:00
|
|
|
}
|
2011-04-12 10:18:43 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-04-13 23:59:15 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-04-12 10:18:43 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::RestoreNormalRefresh()
|
|
|
|
{
|
2014-02-12 08:41:57 +04:00
|
|
|
// 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.
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<LayerTransactionChild> transaction = GetLayerTransaction();
|
2014-05-07 17:23:14 +04:00
|
|
|
if (transaction && transaction->IPCOpen()) {
|
2014-03-22 01:59:57 +04:00
|
|
|
transaction->SendLeaveTestMode();
|
2017-06-28 03:29:06 +03:00
|
|
|
} else if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) {
|
|
|
|
wrbc->SendLeaveTestMode();
|
2014-02-12 08:41:57 +04:00
|
|
|
}
|
|
|
|
|
2015-04-15 23:28:43 +03:00
|
|
|
if (nsPresContext* pc = GetPresContext()) {
|
|
|
|
nsRefreshDriver* driver = pc->RefreshDriver();
|
|
|
|
driver->RestoreNormalRefresh();
|
|
|
|
}
|
2011-04-12 10:18:43 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-03-16 01:40:37 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsTestControllingRefreshes(bool *aResult)
|
|
|
|
{
|
2013-10-18 01:50:24 +04:00
|
|
|
nsPresContext* pc = GetPresContext();
|
2013-03-16 01:40:37 +04:00
|
|
|
*aResult =
|
2013-10-18 01:50:24 +04:00
|
|
|
pc ? pc->RefreshDriver()->IsTestControllingRefreshesEnabled() : false;
|
2013-03-16 01:40:37 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-07-09 16:53:54 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetAsyncPanZoomEnabled(bool *aResult)
|
|
|
|
{
|
|
|
|
nsIWidget* widget = GetWidget();
|
|
|
|
if (widget) {
|
|
|
|
*aResult = widget->AsyncPanZoomEnabled();
|
|
|
|
} else {
|
|
|
|
*aResult = gfxPlatform::AsyncPanZoomEnabled();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-02-14 12:59:23 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetAsyncScrollOffset(nsIDOMNode* aNode,
|
2015-11-12 03:10:23 +03:00
|
|
|
float aX, float aY)
|
2014-02-14 12:59:23 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<Element> element = do_QueryInterface(aNode);
|
|
|
|
if (!element) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
2014-09-02 02:20:13 +04:00
|
|
|
FrameMetrics::ViewID viewId;
|
|
|
|
if (!nsLayoutUtils::FindIDFor(element, &viewId)) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
2014-08-31 07:29:24 +04:00
|
|
|
nsIWidget* widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
LayerManager* manager = widget->GetLayerManager();
|
|
|
|
if (!manager) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2017-05-28 14:48:36 +03:00
|
|
|
if (WebRenderLayerManager* wrlm = manager->AsWebRenderLayerManager()) {
|
|
|
|
WebRenderBridgeChild* wrbc = wrlm->WrBridge();
|
|
|
|
if (!wrbc) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
wrbc->SendSetAsyncScrollOffset(viewId, aX, aY);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2014-08-31 07:29:24 +04:00
|
|
|
ShadowLayerForwarder* forwarder = manager->AsShadowForwarder();
|
2014-02-14 12:59:23 +04:00
|
|
|
if (!forwarder || !forwarder->HasShadowManager()) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
2014-08-31 07:29:24 +04:00
|
|
|
forwarder->GetShadowManager()->SendSetAsyncScrollOffset(viewId, aX, aY);
|
2014-02-14 12:59:23 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-05-24 23:48:26 +03:00
|
|
|
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;
|
|
|
|
}
|
2017-05-28 14:48:36 +03:00
|
|
|
if (WebRenderLayerManager* wrlm = manager->AsWebRenderLayerManager()) {
|
|
|
|
WebRenderBridgeChild* wrbc = wrlm->WrBridge();
|
|
|
|
if (!wrbc) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
wrbc->SendSetAsyncZoom(viewId, aValue);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2015-05-24 23:48:26 +03:00
|
|
|
ShadowLayerForwarder* forwarder = manager->AsShadowForwarder();
|
|
|
|
if (!forwarder || !forwarder->HasShadowManager()) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
forwarder->GetShadowManager()->SendSetAsyncZoom(viewId, aValue);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-06-19 15:25:41 +03:00
|
|
|
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;
|
|
|
|
}
|
2017-05-28 14:48:36 +03:00
|
|
|
if (WebRenderLayerManager* wrlm = manager->AsWebRenderLayerManager()) {
|
|
|
|
WebRenderBridgeChild* wrbc = wrlm->WrBridge();
|
|
|
|
if (!wrbc) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
wrbc->SendFlushApzRepaints();
|
2017-06-23 19:45:49 +03:00
|
|
|
*aOutResult = true;
|
2017-05-28 14:48:36 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2015-06-19 15:25:41 +03:00
|
|
|
ShadowLayerForwarder* forwarder = manager->AsShadowForwarder();
|
|
|
|
if (!forwarder || !forwarder->HasShadowManager()) {
|
|
|
|
*aOutResult = false;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
forwarder->GetShadowManager()->SendFlushApzRepaints();
|
|
|
|
*aOutResult = true;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-01-20 04:45:39 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-03-10 02:35:04 +03:00
|
|
|
nsIFrame* currentFrame = content->GetPrimaryFrame();
|
|
|
|
nsIFrame* rootFrame = shell->GetRootFrame();
|
|
|
|
nsIFrame* scrolledFrame = rootScrollFrame->GetScrolledFrame();
|
|
|
|
bool isFixedPos = true;
|
|
|
|
|
|
|
|
while (currentFrame) {
|
|
|
|
if (currentFrame == rootFrame) {
|
|
|
|
break;
|
2017-06-28 00:23:00 +03:00
|
|
|
}
|
|
|
|
if (currentFrame == scrolledFrame) {
|
2017-03-10 02:35:04 +03:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
2016-01-20 04:45:39 +03:00
|
|
|
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;
|
2016-02-24 02:48:26 +03:00
|
|
|
} else {
|
|
|
|
flags |= layers::ONLY_ZOOM_TO_DEFAULT_SCALE;
|
2016-01-20 04:45:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
CSSRect bounds = nsLayoutUtils::GetBoundingContentRect(content, rootScrollFrame);
|
2016-05-12 23:49:02 +03:00
|
|
|
if (bounds.IsEmpty()) {
|
|
|
|
// Do not zoom on empty bounds. Bail out.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2016-01-20 04:45:39 +03:00
|
|
|
bounds.Inflate(15.0f, 0.0f);
|
|
|
|
widget->ZoomToRect(presShellId, viewId, bounds, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-10-24 03:31:55 +04:00
|
|
|
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);
|
|
|
|
|
2016-08-17 04:37:48 +03:00
|
|
|
nsCSSPropertyID property =
|
2016-05-10 11:44:05 +03:00
|
|
|
nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eIgnoreEnabledState);
|
2017-03-20 13:18:41 +03:00
|
|
|
if (property == eCSSProperty_UNKNOWN ||
|
|
|
|
nsCSSProps::IsShorthand(property)) {
|
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
2010-10-24 03:31:55 +04:00
|
|
|
}
|
|
|
|
|
2016-10-05 10:36:16 +03:00
|
|
|
Element* element = content->AsElement();
|
2017-03-20 13:18:41 +03:00
|
|
|
AnimationValue v1 = AnimationValue::FromString(property, aValue1, element);
|
|
|
|
AnimationValue v2 = AnimationValue::FromString(property, aValue2, element);
|
|
|
|
if (v1.IsNull() || v2.IsNull()) {
|
2010-10-24 03:31:55 +04:00
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
}
|
|
|
|
|
2018-03-22 16:49:21 +03:00
|
|
|
RefPtr<ComputedStyle> computedStyle =
|
2018-03-22 21:20:41 +03:00
|
|
|
nsComputedDOMStyle::GetComputedStyle(element, nullptr);
|
2018-03-22 16:49:21 +03:00
|
|
|
*aResult = v1.ComputeDistance(property, v2, computedStyle);
|
2010-10-24 03:31:55 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2017-04-18 05:12:12 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-04-18 06:15:47 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetUnanimatedComputedStyle(nsIDOMElement* aElement,
|
|
|
|
const nsAString& aPseudoElement,
|
|
|
|
const nsAString& aProperty,
|
2017-11-21 12:03:17 +03:00
|
|
|
int32_t aFlushType,
|
2017-04-18 06:15:47 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-11-21 12:03:17 +03:00
|
|
|
switch (aFlushType) {
|
|
|
|
case FLUSH_NONE:
|
|
|
|
break;
|
|
|
|
case FLUSH_STYLE: {
|
2018-01-23 17:49:00 +03:00
|
|
|
if (nsIDocument* doc = element->GetComposedDoc()) {
|
2017-11-21 12:03:17 +03:00
|
|
|
doc->FlushPendingNotifications(FlushType::Style);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2017-04-18 06:15:47 +03:00
|
|
|
nsIPresShell* shell = GetPresShell();
|
|
|
|
if (!shell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2017-10-03 01:05:19 +03:00
|
|
|
RefPtr<nsAtom> pseudo = nsCSSPseudoElements::GetPseudoAtom(aPseudoElement);
|
2018-03-22 16:49:21 +03:00
|
|
|
RefPtr<ComputedStyle> computedStyle =
|
2018-03-22 21:20:41 +03:00
|
|
|
nsComputedDOMStyle::GetUnanimatedComputedStyleNoFlush(element, pseudo);
|
2018-03-22 16:49:21 +03:00
|
|
|
if (!computedStyle) {
|
2017-11-22 03:57:31 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2017-04-18 06:15:47 +03:00
|
|
|
|
2018-03-22 21:20:41 +03:00
|
|
|
RefPtr<RawServoAnimationValue> value =
|
2018-03-22 16:49:21 +03:00
|
|
|
Servo_ComputedValues_ExtractAnimationValue(computedStyle,
|
2018-03-22 21:20:41 +03:00
|
|
|
propertyID).Consume();
|
|
|
|
if (!value) {
|
|
|
|
return NS_ERROR_FAILURE;
|
2017-04-18 06:15:47 +03:00
|
|
|
}
|
2018-03-22 21:20:41 +03:00
|
|
|
Servo_AnimationValue_Serialize(value, propertyID, &aResult);
|
|
|
|
return NS_OK;
|
2017-04-18 06:15:47 +03:00
|
|
|
}
|
|
|
|
|
2010-09-17 04:43:23 +04:00
|
|
|
nsresult
|
|
|
|
nsDOMWindowUtils::RenderDocument(const nsRect& aRect,
|
2012-08-22 19:56:38 +04:00
|
|
|
uint32_t aFlags,
|
2010-09-17 04:43:23 +04:00
|
|
|
nscolor aBackgroundColor,
|
|
|
|
gfxContext* aThebesContext)
|
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-07-24 03:39:17 +04:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
2010-09-17 04:43:23 +04:00
|
|
|
|
|
|
|
// Get Primary Shell
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = doc->GetShell();
|
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Render Document
|
|
|
|
return presShell->RenderDocument(aRect, aFlags, aBackgroundColor, aThebesContext);
|
|
|
|
}
|
2010-09-17 22:56:53 +04:00
|
|
|
|
2010-10-14 20:19:27 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetDisplayDPI(float *aDPI)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
*aDPI = widget->GetDPI();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-09-24 19:05:00 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetContainerElement(nsIDOMElement** aResult)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2013-09-24 19:05:00 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMElement> element =
|
|
|
|
do_QueryInterface(window->GetFrameElementInternal());
|
|
|
|
|
|
|
|
element.forget(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-02-03 11:47:11 +03:00
|
|
|
#ifdef DEBUG
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool
|
2011-02-03 11:47:11 +03:00
|
|
|
CheckLeafLayers(Layer* aLayer, const nsIntPoint& aOffset, nsIntRegion* aCoveredRegion)
|
|
|
|
{
|
2014-01-27 19:28:47 +04:00
|
|
|
gfx::Matrix transform;
|
2011-02-03 11:47:11 +03:00
|
|
|
if (!aLayer->GetTransform().Is2D(&transform) ||
|
|
|
|
transform.HasNonIntegerTranslation())
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2011-02-03 11:47:11 +03:00
|
|
|
transform.NudgeToIntegers();
|
2016-07-26 17:48:30 +03:00
|
|
|
IntPoint offset = aOffset + IntPoint::Truncate(transform._31, transform._32);
|
2011-02-03 11:47:11 +03:00
|
|
|
|
|
|
|
Layer* child = aLayer->GetFirstChild();
|
|
|
|
if (child) {
|
|
|
|
while (child) {
|
|
|
|
if (!CheckLeafLayers(child, offset, aCoveredRegion))
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2011-02-03 11:47:11 +03:00
|
|
|
child = child->GetNextSibling();
|
|
|
|
}
|
|
|
|
} else {
|
2015-11-29 10:07:55 +03:00
|
|
|
nsIntRegion rgn = aLayer->GetVisibleRegion().ToUnknownRegion();
|
2011-02-03 11:47:11 +03:00
|
|
|
rgn.MoveBy(offset);
|
|
|
|
nsIntRegion tmp;
|
|
|
|
tmp.And(rgn, *aCoveredRegion);
|
|
|
|
if (!tmp.IsEmpty())
|
2011-10-17 18:59:28 +04:00
|
|
|
return false;
|
2011-02-03 11:47:11 +03:00
|
|
|
aCoveredRegion->Or(*aCoveredRegion, rgn);
|
|
|
|
}
|
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
return true;
|
2011-02-03 11:47:11 +03:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 10:19:26 +04:00
|
|
|
nsDOMWindowUtils::LeafLayersPartitionWindow(bool* aResult)
|
2011-02-03 11:47:11 +03:00
|
|
|
{
|
2011-10-17 18:59:28 +04:00
|
|
|
*aResult = true;
|
2011-02-03 11:47:11 +03:00
|
|
|
#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)) {
|
2011-10-17 18:59:28 +04:00
|
|
|
*aResult = false;
|
2011-02-03 11:47:11 +03:00
|
|
|
}
|
2015-11-29 10:07:55 +03:00
|
|
|
if (!coveredRegion.IsEqual(root->GetVisibleRegion().ToUnknownRegion())) {
|
2011-10-17 18:59:28 +04:00
|
|
|
*aResult = false;
|
2011-02-03 11:47:11 +03:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2011-04-26 16:31:21 +04:00
|
|
|
|
2011-10-26 07:23:26 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-05-05 12:23:18 +04:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-26 07:23:26 +04:00
|
|
|
*aResult = frame->CheckAndClearPaintedState();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2017-09-27 07:17:11 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::CheckAndClearDisplayListState(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->CheckAndClearDisplayListState();
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-03-11 21:51:59 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-04-25 06:02:48 +03:00
|
|
|
ColorLayer* colorLayer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame<ColorLayer>(frame);
|
|
|
|
if (colorLayer) {
|
|
|
|
auto color = colorLayer->GetColor();
|
|
|
|
*aResult = color.a == 1.0f;
|
|
|
|
return NS_OK;
|
2015-03-11 21:51:59 +03:00
|
|
|
}
|
|
|
|
|
2017-04-25 06:02:48 +03:00
|
|
|
PaintedLayer* paintedLayer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame<PaintedLayer>(frame);
|
|
|
|
if (paintedLayer) {
|
|
|
|
*aResult = paintedLayer->IsOpaque();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
2015-03-11 21:51:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-04-25 06:02:48 +03:00
|
|
|
PaintedLayer* layer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame<PaintedLayer>(frame);
|
2016-01-26 03:36:48 +03:00
|
|
|
if (!layer) {
|
2015-03-11 21:51:59 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2016-01-26 03:36:48 +03:00
|
|
|
layers.PutEntry(layer);
|
2015-03-11 21:51:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = layers.Count();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-08-13 23:05:34 +04:00
|
|
|
NS_IMETHODIMP
|
2013-10-09 01:00:12 +04:00
|
|
|
nsDOMWindowUtils::EnableDialogs()
|
2012-08-13 23:05:34 +04:00
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2013-10-09 01:00:12 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
2012-08-13 23:05:34 +04:00
|
|
|
|
2017-11-04 01:25:38 +03:00
|
|
|
nsGlobalWindowOuter::Cast(window)->EnableDialogs();
|
2013-10-09 01:00:12 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::DisableDialogs()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2013-10-09 01:00:12 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
2017-11-04 01:25:38 +03:00
|
|
|
nsGlobalWindowOuter::Cast(window)->DisableDialogs();
|
2013-10-09 01:00:12 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::AreDialogsEnabled(bool* aResult)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-08-13 23:05:34 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
2017-11-04 01:25:38 +03:00
|
|
|
*aResult = nsGlobalWindowOuter::Cast(window)->AreDialogsEnabled();
|
2012-08-13 23:05:34 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-06-03 20:33:52 +04:00
|
|
|
NS_IMETHODIMP
|
2014-01-09 21:39:36 +04:00
|
|
|
nsDOMWindowUtils::GetFileId(JS::Handle<JS::Value> aFile, JSContext* aCx,
|
2014-09-27 03:21:57 +04:00
|
|
|
int64_t* _retval)
|
2012-06-03 20:33:52 +04:00
|
|
|
{
|
2014-09-27 03:21:57 +04:00
|
|
|
if (aFile.isPrimitive()) {
|
|
|
|
*_retval = -1;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2014-09-13 20:12:19 +04:00
|
|
|
|
2017-07-10 23:05:24 +03:00
|
|
|
JS::Rooted<JSObject*> obj(aCx, aFile.toObjectOrNull());
|
2014-09-13 20:12:19 +04:00
|
|
|
|
2016-02-17 00:46:08 +03:00
|
|
|
IDBMutableFile* mutableFile = nullptr;
|
2017-07-10 23:05:24 +03:00
|
|
|
if (NS_SUCCEEDED(UNWRAP_OBJECT(IDBMutableFile, &obj, mutableFile))) {
|
2014-09-27 03:21:57 +04:00
|
|
|
*_retval = mutableFile->GetFileId();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2014-09-13 20:12:19 +04:00
|
|
|
|
2015-05-19 17:36:37 +03:00
|
|
|
Blob* blob = nullptr;
|
2017-07-10 23:05:24 +03:00
|
|
|
if (NS_SUCCEEDED(UNWRAP_OBJECT(Blob, &obj, blob))) {
|
2014-09-27 03:21:57 +04:00
|
|
|
*_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;
|
|
|
|
}
|
|
|
|
|
2017-07-10 23:05:24 +03:00
|
|
|
JS::Rooted<JSObject*> obj(aCx, aFile.toObjectOrNull());
|
2014-09-27 03:21:57 +04:00
|
|
|
|
2015-05-18 16:51:54 +03:00
|
|
|
File* file = nullptr;
|
2017-07-10 23:05:24 +03:00
|
|
|
if (NS_SUCCEEDED(UNWRAP_OBJECT(File, &obj, file))) {
|
2014-09-27 03:21:57 +04:00
|
|
|
nsString filePath;
|
2015-05-18 16:51:54 +03:00
|
|
|
ErrorResult rv;
|
|
|
|
file->GetMozFullPathInternal(filePath, rv);
|
|
|
|
if (NS_WARN_IF(rv.Failed())) {
|
|
|
|
return rv.StealNSResult();
|
2012-06-03 20:33:52 +04:00
|
|
|
}
|
2014-09-27 03:21:57 +04:00
|
|
|
|
|
|
|
_retval = filePath;
|
|
|
|
return NS_OK;
|
2012-06-03 20:33:52 +04:00
|
|
|
}
|
|
|
|
|
2014-09-27 03:21:57 +04:00
|
|
|
_retval.Truncate();
|
2011-12-16 11:34:24 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2013-09-11 08:18:36 +04:00
|
|
|
nsDOMWindowUtils::GetFileReferences(const nsAString& aDatabaseName, int64_t aId,
|
2014-01-09 21:39:36 +04:00
|
|
|
JS::Handle<JS::Value> aOptions,
|
2013-09-11 08:18:36 +04:00
|
|
|
int32_t* aRefCnt, int32_t* aDBRefCnt,
|
|
|
|
int32_t* aSliceRefCnt, JSContext* aCx,
|
2011-12-16 11:34:24 +04:00
|
|
|
bool* aResult)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
2011-12-16 11:34:24 +04:00
|
|
|
|
2014-11-28 11:44:12 +03:00
|
|
|
nsCString origin;
|
|
|
|
nsresult rv =
|
2017-03-06 20:38:42 +03:00
|
|
|
quota::QuotaManager::GetInfoFromWindow(window, nullptr, nullptr, &origin);
|
2014-11-28 11:44:12 +03:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2013-09-11 08:18:36 +04:00
|
|
|
IDBOpenDBOptions options;
|
|
|
|
JS::Rooted<JS::Value> optionsVal(aCx, aOptions);
|
|
|
|
if (!options.Init(aCx, optionsVal)) {
|
|
|
|
return NS_ERROR_TYPE_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
quota::PersistenceType persistenceType =
|
2014-11-04 23:44:56 +03:00
|
|
|
quota::PersistenceTypeFromStorage(options.mStorage);
|
|
|
|
|
2016-02-17 00:46:08 +03:00
|
|
|
RefPtr<IndexedDatabaseManager> mgr = IndexedDatabaseManager::Get();
|
2011-12-20 15:23:27 +04:00
|
|
|
|
|
|
|
if (mgr) {
|
2013-09-11 08:18:36 +04:00
|
|
|
rv = mgr->BlockAndGetFileReferences(persistenceType, origin, aDatabaseName,
|
|
|
|
aId, aRefCnt, aDBRefCnt, aSliceRefCnt,
|
|
|
|
aResult);
|
2013-06-05 12:11:23 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*aRefCnt = *aDBRefCnt = *aSliceRefCnt = -1;
|
|
|
|
*aResult = false;
|
2011-12-16 11:34:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2011-12-17 01:11:08 +04:00
|
|
|
|
2015-06-30 15:59:27 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::FlushPendingFileDeletions()
|
|
|
|
{
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<IndexedDatabaseManager> mgr = IndexedDatabaseManager::Get();
|
2015-06-30 15:59:27 +03:00
|
|
|
if (mgr) {
|
|
|
|
nsresult rv = mgr->FlushPendingFileDeletions();
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-02-18 02:35:20 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::IsIncrementalGCEnabled(JSContext* cx, bool* aResult)
|
|
|
|
{
|
2016-07-07 10:56:09 +03:00
|
|
|
*aResult = JS::IsIncrementalGCEnabled(cx);
|
2012-02-18 02:35:20 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-17 01:11:08 +04:00
|
|
|
NS_IMETHODIMP
|
2011-12-24 12:21:26 +04:00
|
|
|
nsDOMWindowUtils::StartPCCountProfiling(JSContext* cx)
|
2011-12-17 01:11:08 +04:00
|
|
|
{
|
|
|
|
js::StartPCCountProfiling(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-12-24 12:21:26 +04:00
|
|
|
nsDOMWindowUtils::StopPCCountProfiling(JSContext* cx)
|
2011-12-17 01:11:08 +04:00
|
|
|
{
|
|
|
|
js::StopPCCountProfiling(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-12-24 12:21:26 +04:00
|
|
|
nsDOMWindowUtils::PurgePCCounts(JSContext* cx)
|
2011-12-17 01:11:08 +04:00
|
|
|
{
|
|
|
|
js::PurgePCCounts(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::GetPCCountScriptCount(JSContext* cx, int32_t *result)
|
2011-12-17 01:11:08 +04:00
|
|
|
{
|
|
|
|
*result = js::GetPCCountScriptCount(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::GetPCCountScriptSummary(int32_t script, JSContext* cx, nsAString& result)
|
2011-12-17 01:11:08 +04:00
|
|
|
{
|
|
|
|
JSString *text = js::GetPCCountScriptSummary(cx, script);
|
|
|
|
if (!text)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2014-07-05 19:30:54 +04:00
|
|
|
if (!AssignJSString(cx, result, text))
|
2011-12-17 01:11:08 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 19:56:38 +04:00
|
|
|
nsDOMWindowUtils::GetPCCountScriptContents(int32_t script, JSContext* cx, nsAString& result)
|
2011-12-17 01:11:08 +04:00
|
|
|
{
|
|
|
|
JSString *text = js::GetPCCountScriptContents(cx, script);
|
|
|
|
if (!text)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2014-07-05 19:30:54 +04:00
|
|
|
if (!AssignJSString(cx, result, text))
|
2011-12-17 01:11:08 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-01-04 10:52:20 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetPaintingSuppressed(bool *aPaintingSuppressed)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-04-02 06:23:51 +04:00
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2012-01-04 10:52:20 +04:00
|
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
|
2012-12-29 05:56:42 +04:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2012-01-04 10:52:20 +04:00
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
*aPaintingSuppressed = presShell->IsPaintingSuppressed();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-03-28 19:53:56 +04:00
|
|
|
NS_IMETHODIMP
|
2014-01-09 21:39:36 +04:00
|
|
|
nsDOMWindowUtils::GetPlugins(JSContext* cx, JS::MutableHandle<JS::Value> aPlugins)
|
2012-03-28 19:53:56 +04:00
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
|
|
|
NS_ENSURE_STATE(doc);
|
2012-03-28 19:53:56 +04:00
|
|
|
|
|
|
|
nsTArray<nsIObjectLoadingContent*> plugins;
|
|
|
|
doc->GetPlugins(plugins);
|
|
|
|
|
2013-05-04 11:52:57 +04:00
|
|
|
JS::Rooted<JSObject*> jsPlugins(cx);
|
2014-06-02 20:40:13 +04:00
|
|
|
nsresult rv = nsTArrayToJSArray(cx, plugins, &jsPlugins);
|
2012-03-31 09:34:16 +04:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2014-01-09 21:39:36 +04:00
|
|
|
aPlugins.setObject(*jsPlugins);
|
2012-03-28 19:53:56 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-04-24 22:52:35 +04:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-04-14 20:19:10 +03:00
|
|
|
nsLayoutUtils::SetScrollPositionClampingScrollPortSize(presShell, CSSSize(aWidth, aHeight));
|
2014-03-26 23:59:35 +04:00
|
|
|
|
2012-04-24 22:52:35 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-05-11 04:56:21 +04:00
|
|
|
|
2012-07-31 06:09:31 +04:00
|
|
|
nsresult
|
2015-05-21 00:52:26 +03:00
|
|
|
nsDOMWindowUtils::RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement)
|
2012-07-31 06:09:31 +04:00
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2012-07-31 06:09:31 +04:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
2015-05-21 00:52:26 +03:00
|
|
|
doc->RemoteFrameFullscreenChanged(aFrameElement);
|
2012-07-31 06:09:31 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsDOMWindowUtils::RemoteFrameFullscreenReverted()
|
|
|
|
{
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2012-07-31 06:09:31 +04:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
doc->RemoteFrameFullscreenReverted();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-05-03 10:58:57 +03:00
|
|
|
static void
|
|
|
|
PrepareForFullscreenChange(nsIPresShell* aPresShell, const nsSize& aSize,
|
|
|
|
nsSize* aOldSize = nullptr)
|
2015-08-27 16:14:49 +03:00
|
|
|
{
|
2016-05-03 10:58:57 +03:00
|
|
|
if (!aPresShell) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (nsRefreshDriver* rd = aPresShell->GetRefreshDriver()) {
|
|
|
|
rd->SetIsResizeSuppressed();
|
2016-06-30 07:57:30 +03:00
|
|
|
// 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();
|
2016-05-03 10:58:57 +03:00
|
|
|
}
|
|
|
|
if (!aSize.IsEmpty()) {
|
|
|
|
if (nsViewManager* viewManager = aPresShell->GetViewManager()) {
|
2015-08-27 16:14:49 +03:00
|
|
|
if (aOldSize) {
|
|
|
|
viewManager->GetWindowDimensions(&aOldSize->width, &aOldSize->height);
|
|
|
|
}
|
|
|
|
viewManager->SetWindowDimensions(aSize.width, aSize.height);
|
|
|
|
}
|
|
|
|
}
|
2016-05-03 10:58:57 +03:00
|
|
|
}
|
2015-08-27 16:14:49 +03:00
|
|
|
|
2015-06-10 14:13:12 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::HandleFullscreenRequests(bool* aRetVal)
|
|
|
|
{
|
2017-10-04 01:11:18 +03:00
|
|
|
PROFILER_ADD_MARKER("Enter fullscreen");
|
2015-06-10 14:13:12 +03:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
2015-08-27 16:14:49 +03:00
|
|
|
// 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;
|
2016-05-03 10:58:57 +03:00
|
|
|
PrepareForFullscreenChange(GetPresShell(), screenRect.Size(), &oldSize);
|
2016-06-21 01:19:50 +03:00
|
|
|
OldWindowSize::Set(mWindow, oldSize);
|
2015-08-27 16:14:49 +03:00
|
|
|
|
2015-06-10 14:13:12 +03:00
|
|
|
*aRetVal = nsIDocument::HandlePendingFullscreenRequests(doc);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-07-31 06:09:31 +04:00
|
|
|
nsresult
|
|
|
|
nsDOMWindowUtils::ExitFullscreen()
|
|
|
|
{
|
2017-10-04 01:11:18 +03:00
|
|
|
PROFILER_ADD_MARKER("Exit fullscreen");
|
2015-07-08 01:51:09 +03:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
|
|
|
NS_ENSURE_STATE(doc);
|
2016-01-11 01:38:53 +03:00
|
|
|
|
|
|
|
// Although we would not use the old size if we have already exited
|
|
|
|
// fullscreen, we still want to cleanup in case we haven't.
|
2016-06-21 01:19:50 +03:00
|
|
|
nsSize oldSize = OldWindowSize::GetAndRemove(mWindow);
|
2016-02-24 03:40:08 +03:00
|
|
|
if (!doc->GetFullscreenElement()) {
|
2015-08-27 16:14:49 +03:00
|
|
|
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.
|
2016-05-03 10:58:57 +03:00
|
|
|
PrepareForFullscreenChange(GetPresShell(), oldSize);
|
2015-07-19 03:30:52 +03:00
|
|
|
nsIDocument::ExitFullscreenInDocTree(doc);
|
2012-07-31 06:09:31 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-09-11 01:02:23 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-09-14 22:55:01 +04:00
|
|
|
nsDOMWindowUtils::SelectAtPoint(float aX, float aY, uint32_t aSelectBehavior,
|
2012-09-11 01:02:23 +04:00
|
|
|
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;
|
2013-05-15 19:08:50 +04:00
|
|
|
default:
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
2012-09-11 01:02:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The root frame for this content window
|
2018-03-06 12:25:21 +03:00
|
|
|
nsIFrame* rootFrame = presShell->GetRootFrame();
|
2012-09-11 01:02:23 +04:00
|
|
|
if (!rootFrame) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the target frame at the client coordinates passed to us
|
2013-02-27 18:12:39 +04:00
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
2015-02-02 01:27:31 +03:00
|
|
|
LayoutDeviceIntPoint pt =
|
2015-04-15 10:08:55 +03:00
|
|
|
nsContentUtils::ToWidgetPoint(CSSPoint(aX, aY), offset, GetPresContext());
|
2012-09-11 01:02:23 +04:00
|
|
|
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;
|
|
|
|
}
|
2012-09-11 15:51:10 +04:00
|
|
|
|
2012-10-29 15:21:15 +04:00
|
|
|
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
|
2015-10-20 02:16:20 +03:00
|
|
|
return nsIDocument::AdditionalSheetTypeCount;
|
2012-10-29 15:21:15 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-11 15:51:10 +04:00
|
|
|
NS_IMETHODIMP
|
2012-09-14 22:55:01 +04:00
|
|
|
nsDOMWindowUtils::LoadSheet(nsIURI *aSheetURI, uint32_t aSheetType)
|
2012-09-11 15:51:10 +04:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
2012-10-29 15:21:15 +04:00
|
|
|
NS_ENSURE_ARG(aSheetType == AGENT_SHEET ||
|
|
|
|
aSheetType == USER_SHEET ||
|
|
|
|
aSheetType == AUTHOR_SHEET);
|
2012-09-11 15:51:10 +04:00
|
|
|
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-07-24 03:39:17 +04:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
2012-09-11 15:51:10 +04:00
|
|
|
|
2012-10-29 15:21:15 +04:00
|
|
|
nsIDocument::additionalSheetType type = convertSheetType(aSheetType);
|
2012-09-11 15:51:10 +04:00
|
|
|
|
2013-07-24 03:39:17 +04:00
|
|
|
return doc->LoadAdditionalStyleSheet(type, aSheetURI);
|
2012-09-11 15:51:10 +04:00
|
|
|
}
|
|
|
|
|
2014-10-31 21:48:52 +03:00
|
|
|
NS_IMETHODIMP
|
2014-11-04 20:32:06 +03:00
|
|
|
nsDOMWindowUtils::LoadSheetUsingURIString(const nsACString& aSheetURI, uint32_t aSheetType)
|
2014-10-31 21:48:52 +03:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
nsresult rv = NS_NewURI(getter_AddRefs(uri), aSheetURI);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return LoadSheet(uri, aSheetType);
|
|
|
|
}
|
|
|
|
|
2014-07-09 13:43:33 +04:00
|
|
|
NS_IMETHODIMP
|
2017-01-05 10:32:22 +03:00
|
|
|
nsDOMWindowUtils::AddSheet(nsIPreloadedStyleSheet* aSheet, uint32_t aSheetType)
|
2014-07-09 13:43:33 +04:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
2017-01-05 10:32:22 +03:00
|
|
|
StyleSheet* sheet = nullptr;
|
|
|
|
auto preloadedSheet = static_cast<PreloadedStyleSheet*>(aSheet);
|
|
|
|
nsresult rv = preloadedSheet->GetSheet(doc->GetStyleBackendType(), &sheet);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2014-07-09 13:43:33 +04:00
|
|
|
NS_ENSURE_TRUE(sheet, NS_ERROR_FAILURE);
|
2017-01-05 10:32:22 +03:00
|
|
|
|
2017-01-20 07:49:44 +03:00
|
|
|
if (sheet->GetAssociatedDocument()) {
|
2014-07-09 13:43:33 +04:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
2017-01-05 10:32:22 +03:00
|
|
|
|
|
|
|
nsIDocument::additionalSheetType type = convertSheetType(aSheetType);
|
2014-07-09 13:43:33 +04:00
|
|
|
return doc->AddAdditionalStyleSheet(type, sheet);
|
|
|
|
}
|
|
|
|
|
2012-09-11 15:51:10 +04:00
|
|
|
NS_IMETHODIMP
|
2012-09-14 22:55:01 +04:00
|
|
|
nsDOMWindowUtils::RemoveSheet(nsIURI *aSheetURI, uint32_t aSheetType)
|
2012-09-11 15:51:10 +04:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
2012-10-29 15:21:15 +04:00
|
|
|
NS_ENSURE_ARG(aSheetType == AGENT_SHEET ||
|
|
|
|
aSheetType == USER_SHEET ||
|
|
|
|
aSheetType == AUTHOR_SHEET);
|
2012-09-11 15:51:10 +04:00
|
|
|
|
2014-03-08 13:22:28 +04:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-07-24 03:39:17 +04:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
2012-09-11 15:51:10 +04:00
|
|
|
|
2012-10-29 15:21:15 +04:00
|
|
|
nsIDocument::additionalSheetType type = convertSheetType(aSheetType);
|
2012-09-11 15:51:10 +04:00
|
|
|
|
|
|
|
doc->RemoveAdditionalStyleSheet(type, aSheetURI);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-10-08 15:02:57 +04:00
|
|
|
|
2014-11-04 20:32:06 +03:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-10-08 15:02:57 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsHandlingUserInput(bool* aHandlingUserInput)
|
|
|
|
{
|
2014-04-01 08:09:23 +04:00
|
|
|
*aHandlingUserInput = EventStateManager::IsHandlingUserInput();
|
2012-10-08 15:02:57 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-10-12 14:17:56 +04:00
|
|
|
|
2016-09-27 17:22:26 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-10-12 14:17:56 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::AllowScriptsToClose()
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2012-10-12 14:17:56 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
2017-11-04 01:25:38 +03:00
|
|
|
nsGlobalWindowOuter::Cast(window)->AllowScriptsToClose();
|
2012-10-12 14:17:56 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2013-01-03 19:17:36 +04:00
|
|
|
|
2013-05-31 05:12:44 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsParentWindowMainWidgetVisible(bool* aIsVisible)
|
|
|
|
{
|
|
|
|
// this should reflect the "is parent window visible" logic in
|
|
|
|
// nsWindowWatcher::OpenWindowInternal()
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2013-05-31 05:12:44 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> parentWidget;
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
|
|
|
if (docShell) {
|
2014-04-05 01:50:42 +04:00
|
|
|
if (TabChild *tabChild = TabChild::GetFrom(docShell)) {
|
|
|
|
if (!tabChild->SendIsParentWindowMainWidgetVisible(aIsVisible))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-05-31 05:12:44 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-01-03 19:17:36 +04:00
|
|
|
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);
|
2015-08-29 02:58:26 +03:00
|
|
|
if (fc && fc->IsDisabledForEvents(eVoidEvent)) {
|
2013-01-03 19:17:36 +04:00
|
|
|
*aRetVal = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
node = node->GetParentNode();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2013-01-16 13:27:06 +04:00
|
|
|
|
2013-03-12 22:01:00 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetPaintFlashing(bool aPaintFlashing)
|
|
|
|
{
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
2013-07-22 19:51:38 +04:00
|
|
|
presContext->SetPaintFlashing(aPaintFlashing);
|
2013-03-12 22:01:00 +04:00
|
|
|
// 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) {
|
2013-07-22 19:51:38 +04:00
|
|
|
*aRetVal = presContext->GetPaintFlashing();
|
2013-03-12 22:01:00 +04:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-01-16 13:27:06 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::DispatchEventToChromeOnly(nsIDOMEventTarget* aTarget,
|
|
|
|
nsIDOMEvent* aEvent,
|
|
|
|
bool* aRetVal)
|
|
|
|
{
|
|
|
|
*aRetVal = false;
|
|
|
|
NS_ENSURE_STATE(aTarget && aEvent);
|
2016-02-12 18:40:07 +03:00
|
|
|
aEvent->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
|
2013-01-16 13:27:06 +04:00
|
|
|
aTarget->DispatchEvent(aEvent, aRetVal);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2013-05-23 05:35:21 +04:00
|
|
|
|
2014-09-02 23:23:34 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-05-30 04:38:27 +04:00
|
|
|
NS_IMETHODIMP
|
2014-03-10 08:47:12 +04:00
|
|
|
nsDOMWindowUtils::GetOMTAStyle(nsIDOMElement* aElement,
|
|
|
|
const nsAString& aProperty,
|
2015-07-01 19:08:30 +03:00
|
|
|
const nsAString& aPseudoElement,
|
2014-03-10 08:47:12 +04:00
|
|
|
nsAString& aResult)
|
2013-05-30 04:38:27 +04:00
|
|
|
{
|
2014-03-10 08:47:12 +04:00
|
|
|
nsCOMPtr<Element> element = do_QueryInterface(aElement);
|
2013-05-30 04:38:27 +04:00
|
|
|
if (!element) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<nsROCSSPrimitiveValue> cssValue = nullptr;
|
2013-05-30 04:38:27 +04:00
|
|
|
nsIFrame* frame = element->GetPrimaryFrame();
|
2017-04-19 13:53:57 +03:00
|
|
|
if (!aPseudoElement.IsEmpty()) {
|
2015-07-01 19:08:30 +03:00
|
|
|
if (aPseudoElement.EqualsLiteral("::before")) {
|
2017-04-19 13:53:57 +03:00
|
|
|
frame = nsLayoutUtils::GetBeforeFrame(element);
|
2015-07-01 19:08:30 +03:00
|
|
|
} else if (aPseudoElement.EqualsLiteral("::after")) {
|
2017-04-19 13:53:57 +03:00
|
|
|
frame = nsLayoutUtils::GetAfterFrame(element);
|
2015-07-01 19:08:30 +03:00
|
|
|
} else {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
}
|
2013-05-31 22:06:56 +04:00
|
|
|
if (frame && nsLayoutUtils::AreAsyncAnimationsEnabled()) {
|
2017-10-25 18:14:41 +03:00
|
|
|
RefPtr<LayerManager> widgetLayerManager;
|
|
|
|
if (nsIWidget* widget = GetWidget()) {
|
|
|
|
widgetLayerManager = widget->GetLayerManager();
|
|
|
|
}
|
|
|
|
|
2013-05-30 04:38:27 +04:00
|
|
|
if (aProperty.EqualsLiteral("opacity")) {
|
2017-10-25 18:14:41 +03:00
|
|
|
float value = 0;
|
|
|
|
bool hadAnimatedOpacity = false;
|
|
|
|
|
2014-03-10 08:47:12 +04:00
|
|
|
Layer* layer =
|
2017-08-07 07:07:43 +03:00
|
|
|
FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_OPACITY);
|
2013-05-30 04:38:27 +04:00
|
|
|
if (layer) {
|
|
|
|
ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
|
2013-11-01 10:36:02 +04:00
|
|
|
if (forwarder && forwarder->HasShadowManager()) {
|
2017-02-10 01:30:11 +03:00
|
|
|
forwarder->GetShadowManager()->
|
|
|
|
SendGetAnimationOpacity(layer->GetCompositorAnimationsId(),
|
|
|
|
&value,
|
|
|
|
&hadAnimatedOpacity);
|
2017-10-25 18:14:41 +03:00
|
|
|
}
|
|
|
|
} else if (WebRenderLayerManager* wrlm = widgetLayerManager->AsWebRenderLayerManager()) {
|
2018-03-16 00:35:56 +03:00
|
|
|
RefPtr<WebRenderAnimationData> animationData =
|
|
|
|
GetWebRenderUserData<WebRenderAnimationData>(frame, (uint32_t)DisplayItemType::TYPE_OPACITY);
|
2017-10-25 18:14:41 +03:00
|
|
|
if (animationData) {
|
2017-06-28 03:29:06 +03:00
|
|
|
wrlm->WrBridge()->SendGetAnimationOpacity(
|
2017-10-25 18:14:41 +03:00
|
|
|
animationData->GetAnimationInfo().GetCompositorAnimationsId(),
|
2017-06-28 03:29:06 +03:00
|
|
|
&value,
|
|
|
|
&hadAnimatedOpacity);
|
|
|
|
}
|
2017-10-25 18:14:41 +03:00
|
|
|
}
|
|
|
|
if (hadAnimatedOpacity) {
|
|
|
|
cssValue = new nsROCSSPrimitiveValue;
|
|
|
|
cssValue->SetNumber(value);
|
2013-05-30 04:38:27 +04:00
|
|
|
}
|
|
|
|
} else if (aProperty.EqualsLiteral("transform")) {
|
2017-10-25 18:14:41 +03:00
|
|
|
MaybeTransform transform;
|
|
|
|
|
2014-03-10 08:47:12 +04:00
|
|
|
Layer* layer =
|
2017-08-07 07:07:43 +03:00
|
|
|
FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_TRANSFORM);
|
2013-05-30 04:38:27 +04:00
|
|
|
if (layer) {
|
|
|
|
ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
|
2013-11-01 10:36:02 +04:00
|
|
|
if (forwarder && forwarder->HasShadowManager()) {
|
2017-02-10 01:30:11 +03:00
|
|
|
forwarder->GetShadowManager()->
|
|
|
|
SendGetAnimationTransform(layer->GetCompositorAnimationsId(), &transform);
|
2017-10-25 18:14:41 +03:00
|
|
|
}
|
|
|
|
} else if (WebRenderLayerManager* wrlm = widgetLayerManager->AsWebRenderLayerManager()) {
|
2018-03-16 00:35:56 +03:00
|
|
|
RefPtr<WebRenderAnimationData> animationData =
|
|
|
|
GetWebRenderUserData<WebRenderAnimationData>(frame, (uint32_t)DisplayItemType::TYPE_TRANSFORM);
|
2017-10-25 18:14:41 +03:00
|
|
|
if (animationData) {
|
2017-06-28 03:29:06 +03:00
|
|
|
wrlm->WrBridge()->SendGetAnimationTransform(
|
2017-10-25 18:14:41 +03:00
|
|
|
animationData->GetAnimationInfo().GetCompositorAnimationsId(),
|
2017-06-28 03:29:06 +03:00
|
|
|
&transform);
|
|
|
|
}
|
2017-10-25 18:14:41 +03:00
|
|
|
}
|
|
|
|
if (transform.type() == MaybeTransform::TMatrix4x4) {
|
|
|
|
Matrix4x4 matrix = transform.get_Matrix4x4();
|
|
|
|
cssValue = nsComputedDOMStyle::MatrixToCSSValue(matrix);
|
2013-05-30 04:38:27 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cssValue) {
|
|
|
|
nsString text;
|
2014-03-10 08:47:12 +04:00
|
|
|
ErrorResult rv;
|
2013-05-30 04:38:27 +04:00
|
|
|
cssValue->GetCssText(text, rv);
|
|
|
|
aResult.Assign(text);
|
2015-04-27 16:18:51 +03:00
|
|
|
return rv.StealNSResult();
|
2013-05-30 04:38:27 +04:00
|
|
|
}
|
2017-02-09 17:44:02 +03:00
|
|
|
aResult.Truncate();
|
2014-03-10 08:47:12 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-07-09 05:27:59 +04:00
|
|
|
namespace {
|
|
|
|
|
2015-03-21 19:28:04 +03:00
|
|
|
class HandlingUserInputHelper final : public nsIJSRAIIHelper
|
2014-07-09 05:27:59 +04:00
|
|
|
{
|
|
|
|
public:
|
2014-09-02 04:49:25 +04:00
|
|
|
explicit HandlingUserInputHelper(bool aHandlingUserInput);
|
2014-07-09 05:27:59 +04:00
|
|
|
|
|
|
|
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) {
|
Bug 1406446 - part 1: InputContextAction should treat focus change during handling a user input as caused by user input even if it's caused by JS r=smaug
Currently, widget doesn't show VKB when input context change is caused by JS.
However, if it's caused by an event handler of a user input, user may expect
to open VKB. For example, if a touch event in fake editor causes moving
focus to actual editable node, user expect to show VKB.
Therefore, InputContextAction should declare two causes. One is unknown but
occurred during handling non-keyboard event. The other is unknown but occurred
during handling keyboard event.
However, EventStateManager doesn't have an API to check if it's being handling
a keyboard event. Therefore, this patch adds it first.
AutoHandlingUserInputStatePusher sends event type to StartHandlingUserInput()
and StopHandlingUserInput() of EventStateManager and sUserKeyboardEventDepth
manages the number of nested keyboard event handling. Therefore,
EventStateManager::IsHandlingKeyboardInput() can return if it's handling a
keyboard event.
IMEStateManager uses this new API to adjust the cause of changes of input
context.
Finally, InputContextAction::IsUserInput() is renamed to IsHandlingUserInput()
for consistency with EventStateManager and starts to return true when the
input context change is caused by script while it's handling a user input.
MozReview-Commit-ID: 5JsLqdqeGah
--HG--
extra : rebase_source : 9fcf7687d1bf90eeebbf6eac62d4488ff64b083c
2017-10-23 20:46:15 +03:00
|
|
|
EventStateManager::StartHandlingUserInput(eVoidEvent);
|
2014-07-09 05:27:59 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
Bug 1406446 - part 1: InputContextAction should treat focus change during handling a user input as caused by user input even if it's caused by JS r=smaug
Currently, widget doesn't show VKB when input context change is caused by JS.
However, if it's caused by an event handler of a user input, user may expect
to open VKB. For example, if a touch event in fake editor causes moving
focus to actual editable node, user expect to show VKB.
Therefore, InputContextAction should declare two causes. One is unknown but
occurred during handling non-keyboard event. The other is unknown but occurred
during handling keyboard event.
However, EventStateManager doesn't have an API to check if it's being handling
a keyboard event. Therefore, this patch adds it first.
AutoHandlingUserInputStatePusher sends event type to StartHandlingUserInput()
and StopHandlingUserInput() of EventStateManager and sUserKeyboardEventDepth
manages the number of nested keyboard event handling. Therefore,
EventStateManager::IsHandlingKeyboardInput() can return if it's handling a
keyboard event.
IMEStateManager uses this new API to adjust the cause of changes of input
context.
Finally, InputContextAction::IsUserInput() is renamed to IsHandlingUserInput()
for consistency with EventStateManager and starts to return true when the
input context change is caused by script while it's handling a user input.
MozReview-Commit-ID: 5JsLqdqeGah
--HG--
extra : rebase_source : 9fcf7687d1bf90eeebbf6eac62d4488ff64b083c
2017-10-23 20:46:15 +03:00
|
|
|
EventStateManager::StopHandlingUserInput(eVoidEvent);
|
2014-07-09 05:27:59 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-07-10 03:30:55 +04:00
|
|
|
} // unnamed namespace
|
2014-07-09 05:27:59 +04:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetHandlingUserInput(bool aHandlingUserInput,
|
|
|
|
nsIJSRAIIHelper** aHelper)
|
|
|
|
{
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<HandlingUserInputHelper> helper(
|
2014-07-09 05:27:59 +04:00
|
|
|
new HandlingUserInputHelper(aHandlingUserInput));
|
|
|
|
helper.forget(aHelper);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-05-10 01:16:03 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetContentAPZTestData(JSContext* aContext,
|
|
|
|
JS::MutableHandleValue aOutContentTestData)
|
|
|
|
{
|
|
|
|
if (nsIWidget* widget = GetWidget()) {
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<LayerManager> lm = widget->GetLayerManager();
|
2016-02-29 09:53:14 +03:00
|
|
|
if (!lm) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
if (ClientLayerManager* clm = lm->AsClientLayerManager()) {
|
2014-05-10 01:16:03 +04:00
|
|
|
if (!clm->GetAPZTestData().ToJS(aOutContentTestData, aContext)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2017-06-05 05:29:35 +03:00
|
|
|
} else if (WebRenderLayerManager* wrlm = lm->AsWebRenderLayerManager()) {
|
|
|
|
if (!wrlm->GetAPZTestData().ToJS(aOutContentTestData, aContext)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2014-05-10 01:16:03 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetCompositorAPZTestData(JSContext* aContext,
|
|
|
|
JS::MutableHandleValue aOutCompositorTestData)
|
|
|
|
{
|
|
|
|
if (nsIWidget* widget = GetWidget()) {
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<LayerManager> lm = widget->GetLayerManager();
|
2016-02-29 09:53:14 +03:00
|
|
|
if (!lm) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2017-06-05 05:29:35 +03:00
|
|
|
APZTestData compositorSideData;
|
2016-02-29 09:53:14 +03:00
|
|
|
if (ClientLayerManager* clm = lm->AsClientLayerManager()) {
|
2014-05-10 01:16:03 +04:00
|
|
|
clm->GetCompositorSideAPZTestData(&compositorSideData);
|
2017-06-05 05:29:35 +03:00
|
|
|
} else if (WebRenderLayerManager* wrlm = lm->AsWebRenderLayerManager()) {
|
|
|
|
if (!wrlm->WrBridge()) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
if (!wrlm->WrBridge()->SendGetAPZTestData(&compositorSideData)) {
|
2014-05-10 01:16:03 +04:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
2017-06-05 05:29:35 +03:00
|
|
|
if (!compositorSideData.ToJS(aOutCompositorTestData, aContext)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2014-05-10 01:16:03 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-04-29 07:47:14 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-04-18 13:48:41 +03:00
|
|
|
NS_IMETHODIMP
|
2016-05-03 04:51:22 +03:00
|
|
|
nsDOMWindowUtils::GetMediaSuspend(uint32_t* aSuspend)
|
2016-04-18 13:48:41 +03:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2016-05-03 04:51:22 +03:00
|
|
|
*aSuspend = window->GetMediaSuspend();
|
2016-04-18 13:48:41 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2016-05-03 04:51:22 +03:00
|
|
|
nsDOMWindowUtils::SetMediaSuspend(uint32_t aSuspend)
|
2016-04-18 13:48:41 +03:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2016-05-03 04:51:22 +03:00
|
|
|
window->SetMediaSuspend(aSuspend);
|
2016-04-18 13:48:41 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-03-11 14:46:55 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetAudioMuted(bool* aMuted)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2014-03-11 14:46:55 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
*aMuted = window->GetAudioMuted();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetAudioMuted(bool aMuted)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2014-03-11 14:46:55 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
window->SetAudioMuted(aMuted);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetAudioVolume(float* aVolume)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2014-03-11 14:46:55 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
*aVolume = window->GetAudioVolume();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetAudioVolume(float aVolume)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2014-03-11 14:46:55 +04:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
return window->SetAudioVolume(aVolume);
|
|
|
|
}
|
2014-04-05 07:21:08 +04:00
|
|
|
|
2015-02-02 15:14:00 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetChromeMargin(int32_t aTop,
|
|
|
|
int32_t aRight,
|
|
|
|
int32_t aBottom,
|
|
|
|
int32_t aLeft)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2015-02-02 15:14:00 +03:00
|
|
|
if (window) {
|
|
|
|
nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(window->GetDocShell());
|
|
|
|
if (baseWindow) {
|
|
|
|
nsCOMPtr<nsIWidget> widget;
|
|
|
|
baseWindow->GetMainWidget(getter_AddRefs(widget));
|
|
|
|
if (widget) {
|
2015-11-12 10:05:04 +03:00
|
|
|
LayoutDeviceIntMargin margins(aTop, aRight, aBottom, aLeft);
|
2015-02-02 15:14:00 +03:00
|
|
|
return widget->SetNonClientMargins(margins);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-06-08 19:53:41 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetFrameUniformityTestData(JSContext* aContext,
|
|
|
|
JS::MutableHandleValue aOutFrameUniformity)
|
|
|
|
{
|
|
|
|
nsIWidget* widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<LayerManager> manager = widget->GetLayerManager();
|
2015-06-08 19:53:41 +03:00
|
|
|
if (!manager) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
FrameUniformityData outData;
|
|
|
|
manager->GetFrameUniformity(&outData);
|
|
|
|
outData.ToJS(aOutFrameUniformity, aContext);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-04-29 03:58:34 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::XpconnectArgument(nsIDOMWindowUtils* aThis)
|
|
|
|
{
|
|
|
|
// Do nothing.
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-07-08 08:45:23 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::AskPermission(nsIContentPermissionRequest* aRequest)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2014-08-01 11:22:20 +04:00
|
|
|
return nsContentPermissionUtils::AskPermission(aRequest, window->GetCurrentInnerWindow());
|
2014-07-08 08:45:23 +04:00
|
|
|
}
|
|
|
|
|
2017-05-26 17:39:11 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetRestyleGeneration(uint64_t* aResult)
|
|
|
|
{
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = presContext->GetRestyleGeneration();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-01-12 02:43:10 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-03-24 21:15:00 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetServiceWorkersTestingEnabled(bool aEnabled)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2015-03-24 21:15:00 +03:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
window->SetServiceWorkersTestingEnabled(aEnabled);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetServiceWorkersTestingEnabled(bool *aEnabled)
|
|
|
|
{
|
2016-01-30 20:05:36 +03:00
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
|
2015-03-24 21:15:00 +03:00
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
*aEnabled = window->GetServiceWorkersTestingEnabled();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-06-04 20:44:55 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::EnterChaosMode()
|
|
|
|
{
|
|
|
|
ChaosMode::enterChaosMode();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::LeaveChaosMode()
|
|
|
|
{
|
|
|
|
ChaosMode::leaveChaosMode();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2017-06-15 21:34:00 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::TriggerDeviceReset()
|
|
|
|
{
|
|
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
|
|
if (cc) {
|
|
|
|
cc->SendDeviceReset();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
GPUProcessManager* pm = GPUProcessManager::Get();
|
|
|
|
if (pm) {
|
2017-07-11 05:30:52 +03:00
|
|
|
pm->SimulateDeviceReset();
|
2017-06-15 21:34:00 +03:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-03-17 22:25:35 +03:00
|
|
|
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();
|
|
|
|
|
2017-01-11 17:52:23 +03:00
|
|
|
// Flush the document and any external documents that it depends on.
|
|
|
|
const auto reportKind
|
|
|
|
= nsDocument::UseCounterReportKind::eIncludeExternalResources;
|
|
|
|
static_cast<nsDocument*>(doc.get())->ReportUseCounters(reportKind);
|
2015-03-17 22:25:35 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nsCOMPtr<nsIContent> content = do_QueryInterface(aNode)) {
|
2018-03-22 00:39:04 +03:00
|
|
|
if (HTMLImageElement* img = HTMLImageElement::FromNode(content)) {
|
2015-03-17 22:25:35 +03:00
|
|
|
img->FlushUseCounters();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2015-07-08 08:57:31 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::HasRuleProcessorUsedByMultipleStyleSets(uint32_t aSheetType,
|
|
|
|
bool* aRetVal)
|
|
|
|
{
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return presShell->HasRuleProcessorUsedByMultipleStyleSets(aSheetType,
|
|
|
|
aRetVal);
|
|
|
|
}
|
|
|
|
|
2016-04-13 17:21:13 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::RespectDisplayPortSuppression(bool aEnabled)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPresShell> shell(GetPresShell());
|
|
|
|
APZCCallbackHelper::RespectDisplayPortSuppression(aEnabled, shell);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-08-24 16:15:42 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::ForceReflowInterrupt()
|
|
|
|
{
|
|
|
|
nsPresContext* pc = GetPresContext();
|
|
|
|
if (!pc) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
pc->SetPendingInterruptFromTest();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-10-31 22:44:40 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-12-01 03:32:23 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-03-06 07:49:04 +03:00
|
|
|
struct StateTableEntry
|
|
|
|
{
|
|
|
|
const char* mStateString;
|
|
|
|
EventStates mState;
|
|
|
|
};
|
|
|
|
|
|
|
|
static constexpr StateTableEntry kManuallyManagedStates[] = {
|
2017-04-20 12:44:14 +03:00
|
|
|
{ "-moz-autofill", NS_EVENT_STATE_AUTOFILL },
|
2017-05-04 08:54:34 +03:00
|
|
|
{ "-moz-autofill-preview", NS_EVENT_STATE_AUTOFILL_PREVIEW },
|
2017-03-06 07:49:04 +03:00
|
|
|
{ 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;
|
|
|
|
}
|
|
|
|
|
2017-05-04 15:29:36 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-06-09 22:59:40 +03:00
|
|
|
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;
|
2017-06-29 07:38:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2017-06-09 22:59:40 +03:00
|
|
|
}
|
|
|
|
|
2017-06-21 08:24:55 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsStyledByServo(bool* aStyledByServo)
|
|
|
|
{
|
2018-03-25 20:42:10 +03:00
|
|
|
*aStyledByServo = true;
|
2017-06-21 08:24:55 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-04-05 07:21:08 +04:00
|
|
|
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;
|
|
|
|
}
|
2018-01-26 18:09:30 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::WrCapture()
|
|
|
|
{
|
|
|
|
if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) {
|
|
|
|
wrbc->Capture();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|