summaryrefslogtreecommitdiffstats
path: root/widget/nsBaseWidget.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'widget/nsBaseWidget.cpp')
-rw-r--r--widget/nsBaseWidget.cpp3326
1 files changed, 3326 insertions, 0 deletions
diff --git a/widget/nsBaseWidget.cpp b/widget/nsBaseWidget.cpp
new file mode 100644
index 000000000..b820fed3c
--- /dev/null
+++ b/widget/nsBaseWidget.cpp
@@ -0,0 +1,3326 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/TextEventDispatcher.h"
+#include "mozilla/TextEventDispatcherListener.h"
+
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/ImageBridgeChild.h"
+#include "nsBaseWidget.h"
+#include "nsDeviceContext.h"
+#include "nsCOMPtr.h"
+#include "nsGfxCIID.h"
+#include "nsWidgetsCID.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIKeyEventInPluginCallback.h"
+#include "nsIScreenManager.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIContent.h"
+#include "nsIDocument.h"
+#include "nsIPresShell.h"
+#include "nsIServiceManager.h"
+#include "mozilla/Preferences.h"
+#include "BasicLayers.h"
+#include "ClientLayerManager.h"
+#include "mozilla/layers/Compositor.h"
+#include "nsIXULRuntime.h"
+#include "nsIXULWindow.h"
+#include "nsIBaseWindow.h"
+#include "nsXULPopupManager.h"
+#include "nsIWidgetListener.h"
+#include "nsIGfxInfo.h"
+#include "npapi.h"
+#include "X11UndefineNone.h"
+#include "base/thread.h"
+#include "prdtoa.h"
+#include "prenv.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Unused.h"
+#include "nsContentUtils.h"
+#include "gfxPrefs.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/MouseEvents.h"
+#include "GLConsts.h"
+#include "mozilla/Unused.h"
+#include "mozilla/IMEStateManager.h"
+#include "mozilla/VsyncDispatcher.h"
+#include "mozilla/layers/IAPZCTreeManager.h"
+#include "mozilla/layers/APZEventState.h"
+#include "mozilla/layers/APZThreadUtils.h"
+#include "mozilla/layers/ChromeProcessController.h"
+#include "mozilla/layers/InputAPZContext.h"
+#include "mozilla/layers/APZCCallbackHelper.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/TabParent.h"
+#include "mozilla/gfx/GPUProcessManager.h"
+#include "mozilla/Move.h"
+#include "mozilla/Services.h"
+#include "mozilla/Sprintf.h"
+#include "nsRefPtrHashtable.h"
+#include "TouchEvents.h"
+#include "WritingModes.h"
+#include "InputData.h"
+#include "FrameLayerBuilder.h"
+#ifdef ACCESSIBILITY
+#include "nsAccessibilityService.h"
+#endif
+#include "gfxConfig.h"
+#include "mozilla/layers/CompositorSession.h"
+#include "VRManagerChild.h"
+
+#ifdef DEBUG
+#include "nsIObserver.h"
+
+static void debug_RegisterPrefCallbacks();
+
+#endif
+
+#ifdef NOISY_WIDGET_LEAKS
+static int32_t gNumWidgets;
+#endif
+
+#ifdef XP_MACOSX
+#include "nsCocoaFeatures.h"
+#endif
+
+#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
+static nsRefPtrHashtable<nsVoidPtrHashKey, nsIWidget>* sPluginWidgetList;
+#endif
+
+nsIRollupListener* nsBaseWidget::gRollupListener = nullptr;
+
+using namespace mozilla::dom;
+using namespace mozilla::layers;
+using namespace mozilla::ipc;
+using namespace mozilla::widget;
+using namespace mozilla;
+using base::Thread;
+
+nsIContent* nsBaseWidget::mLastRollup = nullptr;
+// Global user preference for disabling native theme. Used
+// in NativeWindowTheme.
+bool gDisableNativeTheme = false;
+
+// Async pump timer during injected long touch taps
+#define TOUCH_INJECT_PUMP_TIMER_MSEC 50
+#define TOUCH_INJECT_LONG_TAP_DEFAULT_MSEC 1500
+int32_t nsIWidget::sPointerIdCounter = 0;
+
+// Some statics from nsIWidget.h
+/*static*/ uint64_t AutoObserverNotifier::sObserverId = 0;
+/*static*/ nsDataHashtable<nsUint64HashKey, nsCOMPtr<nsIObserver>> AutoObserverNotifier::sSavedObservers;
+
+namespace mozilla {
+namespace widget {
+
+void
+IMENotification::SelectionChangeDataBase::SetWritingMode(
+ const WritingMode& aWritingMode)
+{
+ mWritingMode = aWritingMode.mWritingMode;
+}
+
+WritingMode
+IMENotification::SelectionChangeDataBase::GetWritingMode() const
+{
+ return WritingMode(mWritingMode);
+}
+
+} // namespace widget
+} // namespace mozilla
+
+nsAutoRollup::nsAutoRollup()
+{
+ // remember if mLastRollup was null, and only clear it upon destruction
+ // if so. This prevents recursive usage of nsAutoRollup from clearing
+ // mLastRollup when it shouldn't.
+ wasClear = !nsBaseWidget::mLastRollup;
+}
+
+nsAutoRollup::~nsAutoRollup()
+{
+ if (nsBaseWidget::mLastRollup && wasClear) {
+ NS_RELEASE(nsBaseWidget::mLastRollup);
+ }
+}
+
+NS_IMPL_ISUPPORTS(nsBaseWidget, nsIWidget, nsISupportsWeakReference)
+
+//-------------------------------------------------------------------------
+//
+// nsBaseWidget constructor
+//
+//-------------------------------------------------------------------------
+
+nsBaseWidget::nsBaseWidget()
+: mWidgetListener(nullptr)
+, mAttachedWidgetListener(nullptr)
+, mPreviouslyAttachedWidgetListener(nullptr)
+, mLayerManager(nullptr)
+, mCompositorVsyncDispatcher(nullptr)
+, mCursor(eCursor_standard)
+, mBorderStyle(eBorderStyle_none)
+, mBounds(0,0,0,0)
+, mOriginalBounds(nullptr)
+, mClipRectCount(0)
+, mSizeMode(nsSizeMode_Normal)
+, mPopupLevel(ePopupLevelTop)
+, mPopupType(ePopupTypeAny)
+, mCompositorWidgetDelegate(nullptr)
+, mUpdateCursor(true)
+, mUseAttachedEvents(false)
+, mIMEHasFocus(false)
+#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
+, mAccessibilityInUseFlag(false)
+#endif
+{
+#ifdef NOISY_WIDGET_LEAKS
+ gNumWidgets++;
+ printf("WIDGETS+ = %d\n", gNumWidgets);
+#endif
+
+#ifdef DEBUG
+ debug_RegisterPrefCallbacks();
+#endif
+
+#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
+ if (!sPluginWidgetList) {
+ sPluginWidgetList = new nsRefPtrHashtable<nsVoidPtrHashKey, nsIWidget>();
+ }
+#endif
+ mShutdownObserver = new WidgetShutdownObserver(this);
+}
+
+NS_IMPL_ISUPPORTS(WidgetShutdownObserver, nsIObserver)
+
+WidgetShutdownObserver::WidgetShutdownObserver(nsBaseWidget* aWidget) :
+ mWidget(aWidget),
+ mRegistered(false)
+{
+ Register();
+}
+
+WidgetShutdownObserver::~WidgetShutdownObserver()
+{
+ // No need to call Unregister(), we can't be destroyed until nsBaseWidget
+ // gets torn down. The observer service and nsBaseWidget have a ref on us
+ // so nsBaseWidget has to call Unregister and then clear its ref.
+}
+
+NS_IMETHODIMP
+WidgetShutdownObserver::Observe(nsISupports *aSubject,
+ const char *aTopic,
+ const char16_t *aData)
+{
+ if (mWidget && !strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+ RefPtr<nsBaseWidget> widget(mWidget);
+ widget->Shutdown();
+ }
+ return NS_OK;
+}
+
+void
+WidgetShutdownObserver::Register()
+{
+ if (!mRegistered) {
+ mRegistered = true;
+ nsContentUtils::RegisterShutdownObserver(this);
+ }
+}
+
+void
+WidgetShutdownObserver::Unregister()
+{
+ if (mRegistered) {
+ mWidget = nullptr;
+ nsContentUtils::UnregisterShutdownObserver(this);
+ mRegistered = false;
+ }
+}
+
+void
+nsBaseWidget::Shutdown()
+{
+ RevokeTransactionIdAllocator();
+ DestroyCompositor();
+ FreeShutdownObserver();
+#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
+ if (sPluginWidgetList) {
+ delete sPluginWidgetList;
+ sPluginWidgetList = nullptr;
+ }
+#endif
+}
+
+void nsBaseWidget::DestroyCompositor()
+{
+ // We release this before releasing the compositor, since it may hold the
+ // last reference to our ClientLayerManager. ClientLayerManager's dtor can
+ // trigger a paint, creating a new compositor, and we don't want to re-use
+ // the old vsync dispatcher.
+ if (mCompositorVsyncDispatcher) {
+ mCompositorVsyncDispatcher->Shutdown();
+ mCompositorVsyncDispatcher = nullptr;
+ }
+
+ // The compositor shutdown sequence looks like this:
+ // 1. CompositorSession calls CompositorBridgeChild::Destroy.
+ // 2. CompositorBridgeChild synchronously sends WillClose.
+ // 3. CompositorBridgeParent releases some resources (such as the layer
+ // manager, compositor, and widget).
+ // 4. CompositorBridgeChild::Destroy returns.
+ // 5. Asynchronously, CompositorBridgeParent::ActorDestroy will fire on the
+ // compositor thread when the I/O thread closes the IPC channel.
+ // 6. Step 5 will schedule DeferredDestroy on the compositor thread, which
+ // releases the reference CompositorBridgeParent holds to itself.
+ //
+ // When CompositorSession::Shutdown returns, we assume the compositor is gone
+ // or will be gone very soon.
+ if (mCompositorSession) {
+ ReleaseContentController();
+ mAPZC = nullptr;
+ mCompositorWidgetDelegate = nullptr;
+ mCompositorBridgeChild = nullptr;
+
+ // XXX CompositorBridgeChild and CompositorBridgeParent might be re-created in
+ // ClientLayerManager destructor. See bug 1133426.
+ RefPtr<CompositorSession> session = mCompositorSession.forget();
+ session->Shutdown();
+ }
+}
+
+// This prevents the layer manager from starting a new transaction during
+// shutdown.
+void
+nsBaseWidget::RevokeTransactionIdAllocator()
+{
+ if (!mLayerManager) {
+ return;
+ }
+
+ ClientLayerManager* clm = mLayerManager->AsClientLayerManager();
+ if (!clm) {
+ return;
+ }
+
+ clm->SetTransactionIdAllocator(nullptr);
+}
+
+void nsBaseWidget::ReleaseContentController()
+{
+ if (mRootContentController) {
+ mRootContentController->Destroy();
+ mRootContentController = nullptr;
+ }
+}
+
+void nsBaseWidget::DestroyLayerManager()
+{
+ if (mLayerManager) {
+ mLayerManager->Destroy();
+ mLayerManager = nullptr;
+ }
+ DestroyCompositor();
+}
+
+void
+nsBaseWidget::OnRenderingDeviceReset()
+{
+ if (!mLayerManager || !mCompositorSession) {
+ return;
+ }
+
+ nsTArray<LayersBackend> backendHints;
+ gfxPlatform::GetPlatform()->GetCompositorBackends(ComputeShouldAccelerate(), backendHints);
+
+ // If the existing compositor does not use acceleration, and this widget
+ // should not be accelerated, then there's no point in resetting.
+ //
+ // Note that if this widget should be accelerated, but instead has a basic
+ // compositor, we still reset just in case we're now in the position to get
+ // accelerated layers again.
+ RefPtr<ClientLayerManager> clm = mLayerManager->AsClientLayerManager();
+ if (!ComputeShouldAccelerate() &&
+ clm->GetTextureFactoryIdentifier().mParentBackend != LayersBackend::LAYERS_BASIC)
+ {
+ return;
+ }
+
+ // Recreate the compositor.
+ TextureFactoryIdentifier identifier;
+ if (!mCompositorSession->Reset(backendHints, &identifier)) {
+ // No action was taken, so we don't have to do anything.
+ return;
+ }
+
+ // Invalidate all layers.
+ FrameLayerBuilder::InvalidateAllLayers(mLayerManager);
+
+ // Update the texture factory identifier.
+ clm->UpdateTextureFactoryIdentifier(identifier);
+ ImageBridgeChild::IdentifyCompositorTextureHost(identifier);
+ gfx::VRManagerChild::IdentifyTextureHost(identifier);
+}
+
+void
+nsBaseWidget::FreeShutdownObserver()
+{
+ if (mShutdownObserver) {
+ mShutdownObserver->Unregister();
+ }
+ mShutdownObserver = nullptr;
+}
+
+//-------------------------------------------------------------------------
+//
+// nsBaseWidget destructor
+//
+//-------------------------------------------------------------------------
+
+nsBaseWidget::~nsBaseWidget()
+{
+ IMEStateManager::WidgetDestroyed(this);
+
+ if (mLayerManager) {
+ if (BasicLayerManager* mgr = mLayerManager->AsBasicLayerManager()) {
+ mgr->ClearRetainerWidget();
+ }
+ }
+
+ FreeShutdownObserver();
+ RevokeTransactionIdAllocator();
+ DestroyLayerManager();
+
+#ifdef NOISY_WIDGET_LEAKS
+ gNumWidgets--;
+ printf("WIDGETS- = %d\n", gNumWidgets);
+#endif
+
+ delete mOriginalBounds;
+}
+
+//-------------------------------------------------------------------------
+//
+// Basic create.
+//
+//-------------------------------------------------------------------------
+void nsBaseWidget::BaseCreate(nsIWidget* aParent,
+ nsWidgetInitData* aInitData)
+{
+ static bool gDisableNativeThemeCached = false;
+ if (!gDisableNativeThemeCached) {
+ Preferences::AddBoolVarCache(&gDisableNativeTheme,
+ "mozilla.widget.disable-native-theme",
+ gDisableNativeTheme);
+ gDisableNativeThemeCached = true;
+ }
+
+ // keep a reference to the device context
+ if (nullptr != aInitData) {
+ mWindowType = aInitData->mWindowType;
+ mBorderStyle = aInitData->mBorderStyle;
+ mPopupLevel = aInitData->mPopupLevel;
+ mPopupType = aInitData->mPopupHint;
+ }
+
+ if (aParent) {
+ aParent->AddChild(this);
+ }
+}
+
+//-------------------------------------------------------------------------
+//
+// Accessor functions to get/set the client data
+//
+//-------------------------------------------------------------------------
+
+nsIWidgetListener* nsBaseWidget::GetWidgetListener()
+{
+ return mWidgetListener;
+}
+
+void nsBaseWidget::SetWidgetListener(nsIWidgetListener* aWidgetListener)
+{
+ mWidgetListener = aWidgetListener;
+}
+
+already_AddRefed<nsIWidget>
+nsBaseWidget::CreateChild(const LayoutDeviceIntRect& aRect,
+ nsWidgetInitData* aInitData,
+ bool aForceUseIWidgetParent)
+{
+ nsIWidget* parent = this;
+ nsNativeWidget nativeParent = nullptr;
+
+ if (!aForceUseIWidgetParent) {
+ // Use only either parent or nativeParent, not both, to match
+ // existing code. Eventually Create() should be divested of its
+ // nativeWidget parameter.
+ nativeParent = parent ? parent->GetNativeData(NS_NATIVE_WIDGET) : nullptr;
+ parent = nativeParent ? nullptr : parent;
+ MOZ_ASSERT(!parent || !nativeParent, "messed up logic");
+ }
+
+ nsCOMPtr<nsIWidget> widget;
+ if (aInitData && aInitData->mWindowType == eWindowType_popup) {
+ widget = AllocateChildPopupWidget();
+ } else {
+ static NS_DEFINE_IID(kCChildCID, NS_CHILD_CID);
+ widget = do_CreateInstance(kCChildCID);
+ }
+
+ if (widget &&
+ NS_SUCCEEDED(widget->Create(parent, nativeParent, aRect, aInitData))) {
+ return widget.forget();
+ }
+
+ return nullptr;
+}
+
+// Attach a view to our widget which we'll send events to.
+void
+nsBaseWidget::AttachViewToTopLevel(bool aUseAttachedEvents)
+{
+ NS_ASSERTION((mWindowType == eWindowType_toplevel ||
+ mWindowType == eWindowType_dialog ||
+ mWindowType == eWindowType_invisible ||
+ mWindowType == eWindowType_child),
+ "Can't attach to window of that type");
+
+ mUseAttachedEvents = aUseAttachedEvents;
+}
+
+nsIWidgetListener* nsBaseWidget::GetAttachedWidgetListener()
+ {
+ return mAttachedWidgetListener;
+ }
+
+nsIWidgetListener* nsBaseWidget::GetPreviouslyAttachedWidgetListener()
+ {
+ return mPreviouslyAttachedWidgetListener;
+ }
+
+void nsBaseWidget::SetPreviouslyAttachedWidgetListener(nsIWidgetListener* aListener)
+ {
+ mPreviouslyAttachedWidgetListener = aListener;
+ }
+
+void nsBaseWidget::SetAttachedWidgetListener(nsIWidgetListener* aListener)
+ {
+ mAttachedWidgetListener = aListener;
+ }
+
+//-------------------------------------------------------------------------
+//
+// Close this nsBaseWidget
+//
+//-------------------------------------------------------------------------
+void nsBaseWidget::Destroy()
+{
+ // Just in case our parent is the only ref to us
+ nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
+ // disconnect from the parent
+ nsIWidget *parent = GetParent();
+ if (parent) {
+ parent->RemoveChild(this);
+ }
+
+#if defined(XP_WIN)
+ // Allow our scroll capture container to be cleaned up, if we have one.
+ mScrollCaptureContainer = nullptr;
+#endif
+}
+
+
+//-------------------------------------------------------------------------
+//
+// Set this nsBaseWidget's parent
+//
+//-------------------------------------------------------------------------
+NS_IMETHODIMP nsBaseWidget::SetParent(nsIWidget* aNewParent)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+//-------------------------------------------------------------------------
+//
+// Get this nsBaseWidget parent
+//
+//-------------------------------------------------------------------------
+nsIWidget* nsBaseWidget::GetParent(void)
+{
+ return nullptr;
+}
+
+//-------------------------------------------------------------------------
+//
+// Get this nsBaseWidget top level widget
+//
+//-------------------------------------------------------------------------
+nsIWidget* nsBaseWidget::GetTopLevelWidget()
+{
+ nsIWidget *topLevelWidget = nullptr, *widget = this;
+ while (widget) {
+ topLevelWidget = widget;
+ widget = widget->GetParent();
+ }
+ return topLevelWidget;
+}
+
+//-------------------------------------------------------------------------
+//
+// Get this nsBaseWidget's top (non-sheet) parent (if it's a sheet)
+//
+//-------------------------------------------------------------------------
+nsIWidget* nsBaseWidget::GetSheetWindowParent(void)
+{
+ return nullptr;
+}
+
+float nsBaseWidget::GetDPI()
+{
+ return 96.0f;
+}
+
+CSSToLayoutDeviceScale nsIWidget::GetDefaultScale()
+{
+ double devPixelsPerCSSPixel = DefaultScaleOverride();
+
+ if (devPixelsPerCSSPixel <= 0.0) {
+ devPixelsPerCSSPixel = GetDefaultScaleInternal();
+ }
+
+ return CSSToLayoutDeviceScale(devPixelsPerCSSPixel);
+}
+
+/* static */
+double nsIWidget::DefaultScaleOverride()
+{
+ // The number of device pixels per CSS pixel. A value <= 0 means choose
+ // automatically based on the DPI. A positive value is used as-is. This effectively
+ // controls the size of a CSS "px".
+ double devPixelsPerCSSPixel = -1.0;
+
+ nsAdoptingCString prefString = Preferences::GetCString("layout.css.devPixelsPerPx");
+ if (!prefString.IsEmpty()) {
+ devPixelsPerCSSPixel = PR_strtod(prefString, nullptr);
+ }
+
+ return devPixelsPerCSSPixel;
+}
+
+//-------------------------------------------------------------------------
+//
+// Add a child to the list of children
+//
+//-------------------------------------------------------------------------
+void nsBaseWidget::AddChild(nsIWidget* aChild)
+{
+ MOZ_ASSERT(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
+ "aChild not properly removed from its old child list");
+
+ if (!mFirstChild) {
+ mFirstChild = mLastChild = aChild;
+ } else {
+ // append to the list
+ MOZ_ASSERT(mLastChild);
+ MOZ_ASSERT(!mLastChild->GetNextSibling());
+ mLastChild->SetNextSibling(aChild);
+ aChild->SetPrevSibling(mLastChild);
+ mLastChild = aChild;
+ }
+}
+
+
+//-------------------------------------------------------------------------
+//
+// Remove a child from the list of children
+//
+//-------------------------------------------------------------------------
+void nsBaseWidget::RemoveChild(nsIWidget* aChild)
+{
+#ifdef DEBUG
+#ifdef XP_MACOSX
+ // nsCocoaWindow doesn't implement GetParent, so in that case parent will be
+ // null and we'll just have to do without this assertion.
+ nsIWidget* parent = aChild->GetParent();
+ NS_ASSERTION(!parent || parent == this, "Not one of our kids!");
+#else
+ MOZ_RELEASE_ASSERT(aChild->GetParent() == this, "Not one of our kids!");
+#endif
+#endif
+
+ if (mLastChild == aChild) {
+ mLastChild = mLastChild->GetPrevSibling();
+ }
+ if (mFirstChild == aChild) {
+ mFirstChild = mFirstChild->GetNextSibling();
+ }
+
+ // Now remove from the list. Make sure that we pass ownership of the tail
+ // of the list correctly before we have aChild let go of it.
+ nsIWidget* prev = aChild->GetPrevSibling();
+ nsIWidget* next = aChild->GetNextSibling();
+ if (prev) {
+ prev->SetNextSibling(next);
+ }
+ if (next) {
+ next->SetPrevSibling(prev);
+ }
+
+ aChild->SetNextSibling(nullptr);
+ aChild->SetPrevSibling(nullptr);
+}
+
+
+//-------------------------------------------------------------------------
+//
+// Sets widget's position within its parent's child list.
+//
+//-------------------------------------------------------------------------
+void nsBaseWidget::SetZIndex(int32_t aZIndex)
+{
+ // Hold a ref to ourselves just in case, since we're going to remove
+ // from our parent.
+ nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
+
+ mZIndex = aZIndex;
+
+ // reorder this child in its parent's list.
+ nsBaseWidget* parent = static_cast<nsBaseWidget*>(GetParent());
+ if (parent) {
+ parent->RemoveChild(this);
+ // Scope sib outside the for loop so we can check it afterward
+ nsIWidget* sib = parent->GetFirstChild();
+ for ( ; sib; sib = sib->GetNextSibling()) {
+ int32_t childZIndex = GetZIndex();
+ if (aZIndex < childZIndex) {
+ // Insert ourselves before sib
+ nsIWidget* prev = sib->GetPrevSibling();
+ mNextSibling = sib;
+ mPrevSibling = prev;
+ sib->SetPrevSibling(this);
+ if (prev) {
+ prev->SetNextSibling(this);
+ } else {
+ NS_ASSERTION(sib == parent->mFirstChild, "Broken child list");
+ // We've taken ownership of sib, so it's safe to have parent let
+ // go of it
+ parent->mFirstChild = this;
+ }
+ PlaceBehind(eZPlacementBelow, sib, false);
+ break;
+ }
+ }
+ // were we added to the list?
+ if (!sib) {
+ parent->AddChild(this);
+ }
+ }
+}
+
+//-------------------------------------------------------------------------
+//
+// Maximize, minimize or restore the window. The BaseWidget implementation
+// merely stores the state.
+//
+//-------------------------------------------------------------------------
+void
+nsBaseWidget::SetSizeMode(nsSizeMode aMode)
+{
+ MOZ_ASSERT(aMode == nsSizeMode_Normal ||
+ aMode == nsSizeMode_Minimized ||
+ aMode == nsSizeMode_Maximized ||
+ aMode == nsSizeMode_Fullscreen);
+ mSizeMode = aMode;
+}
+
+//-------------------------------------------------------------------------
+//
+// Get this component cursor
+//
+//-------------------------------------------------------------------------
+nsCursor nsBaseWidget::GetCursor()
+{
+ return mCursor;
+}
+
+NS_IMETHODIMP nsBaseWidget::SetCursor(nsCursor aCursor)
+{
+ mCursor = aCursor;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsBaseWidget::SetCursor(imgIContainer* aCursor,
+ uint32_t aHotspotX, uint32_t aHotspotY)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+//-------------------------------------------------------------------------
+//
+// Window transparency methods
+//
+//-------------------------------------------------------------------------
+
+void nsBaseWidget::SetTransparencyMode(nsTransparencyMode aMode) {
+}
+
+nsTransparencyMode nsBaseWidget::GetTransparencyMode() {
+ return eTransparencyOpaque;
+}
+
+bool
+nsBaseWidget::IsWindowClipRegionEqual(const nsTArray<LayoutDeviceIntRect>& aRects)
+{
+ return mClipRects &&
+ mClipRectCount == aRects.Length() &&
+ memcmp(mClipRects.get(), aRects.Elements(), sizeof(LayoutDeviceIntRect)*mClipRectCount) == 0;
+}
+
+void
+nsBaseWidget::StoreWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects)
+{
+ mClipRectCount = aRects.Length();
+ mClipRects = MakeUnique<LayoutDeviceIntRect[]>(mClipRectCount);
+ if (mClipRects) {
+ memcpy(mClipRects.get(), aRects.Elements(), sizeof(LayoutDeviceIntRect)*mClipRectCount);
+ }
+}
+
+void
+nsBaseWidget::GetWindowClipRegion(nsTArray<LayoutDeviceIntRect>* aRects)
+{
+ if (mClipRects) {
+ aRects->AppendElements(mClipRects.get(), mClipRectCount);
+ } else {
+ aRects->AppendElement(LayoutDeviceIntRect(0, 0, mBounds.width, mBounds.height));
+ }
+}
+
+const LayoutDeviceIntRegion
+nsBaseWidget::RegionFromArray(const nsTArray<LayoutDeviceIntRect>& aRects)
+{
+ LayoutDeviceIntRegion region;
+ for (uint32_t i = 0; i < aRects.Length(); ++i) {
+ region.Or(region, aRects[i]);
+ }
+ return region;
+}
+
+void
+nsBaseWidget::ArrayFromRegion(const LayoutDeviceIntRegion& aRegion,
+ nsTArray<LayoutDeviceIntRect>& aRects)
+{
+ for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
+ aRects.AppendElement(iter.Get());
+ }
+}
+
+nsresult
+nsBaseWidget::SetWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects,
+ bool aIntersectWithExisting)
+{
+ if (!aIntersectWithExisting) {
+ StoreWindowClipRegion(aRects);
+ } else {
+ // get current rects
+ nsTArray<LayoutDeviceIntRect> currentRects;
+ GetWindowClipRegion(&currentRects);
+ // create region from them
+ LayoutDeviceIntRegion currentRegion = RegionFromArray(currentRects);
+ // create region from new rects
+ LayoutDeviceIntRegion newRegion = RegionFromArray(aRects);
+ // intersect regions
+ LayoutDeviceIntRegion intersection;
+ intersection.And(currentRegion, newRegion);
+ // create int rect array from intersection
+ nsTArray<LayoutDeviceIntRect> rects;
+ ArrayFromRegion(intersection, rects);
+ // store
+ StoreWindowClipRegion(rects);
+ }
+ return NS_OK;
+}
+
+//-------------------------------------------------------------------------
+//
+// Hide window borders/decorations for this widget
+//
+//-------------------------------------------------------------------------
+NS_IMETHODIMP nsBaseWidget::HideWindowChrome(bool aShouldHide)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* virtual */ void
+nsBaseWidget::PerformFullscreenTransition(FullscreenTransitionStage aStage,
+ uint16_t aDuration,
+ nsISupports* aData,
+ nsIRunnable* aCallback)
+{
+ MOZ_ASSERT_UNREACHABLE(
+ "Should never call PerformFullscreenTransition on nsBaseWidget");
+}
+
+//-------------------------------------------------------------------------
+//
+// Put the window into full-screen mode
+//
+//-------------------------------------------------------------------------
+void
+nsBaseWidget::InfallibleMakeFullScreen(bool aFullScreen, nsIScreen* aScreen)
+{
+ HideWindowChrome(aFullScreen);
+
+ if (aFullScreen) {
+ if (!mOriginalBounds) {
+ mOriginalBounds = new LayoutDeviceIntRect();
+ }
+ *mOriginalBounds = GetScreenBounds();
+
+ // Move to top-left corner of screen and size to the screen dimensions
+ nsCOMPtr<nsIScreen> screen = aScreen;
+ if (!screen) {
+ screen = GetWidgetScreen();
+ }
+ if (screen) {
+ int32_t left, top, width, height;
+ if (NS_SUCCEEDED(screen->GetRectDisplayPix(&left, &top, &width, &height))) {
+ Resize(left, top, width, height, true);
+ }
+ }
+ } else if (mOriginalBounds) {
+ if (BoundsUseDesktopPixels()) {
+ DesktopRect deskRect = *mOriginalBounds / GetDesktopToDeviceScale();
+ Resize(deskRect.x, deskRect.y, deskRect.width, deskRect.height, true);
+ } else {
+ Resize(mOriginalBounds->x, mOriginalBounds->y, mOriginalBounds->width,
+ mOriginalBounds->height, true);
+ }
+ }
+}
+
+nsresult
+nsBaseWidget::MakeFullScreen(bool aFullScreen, nsIScreen* aScreen)
+{
+ InfallibleMakeFullScreen(aFullScreen, aScreen);
+ return NS_OK;
+}
+
+nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
+ nsBaseWidget* aWidget, gfxContext* aTarget,
+ BufferMode aDoubleBuffering, ScreenRotation aRotation)
+ : mWidget(aWidget)
+{
+ LayerManager* lm = mWidget->GetLayerManager();
+ NS_ASSERTION(!lm || lm->GetBackendType() == LayersBackend::LAYERS_BASIC,
+ "AutoLayerManagerSetup instantiated for non-basic layer backend!");
+ if (lm) {
+ mLayerManager = lm->AsBasicLayerManager();
+ if (mLayerManager) {
+ mLayerManager->SetDefaultTarget(aTarget);
+ mLayerManager->SetDefaultTargetConfiguration(aDoubleBuffering, aRotation);
+ }
+ }
+}
+
+nsBaseWidget::AutoLayerManagerSetup::~AutoLayerManagerSetup()
+{
+ if (mLayerManager) {
+ mLayerManager->SetDefaultTarget(nullptr);
+ mLayerManager->SetDefaultTargetConfiguration(mozilla::layers::BufferMode::BUFFER_NONE, ROTATION_0);
+ }
+}
+
+bool nsBaseWidget::IsSmallPopup() const
+{
+ return mWindowType == eWindowType_popup && mPopupType != ePopupTypePanel;
+}
+
+bool
+nsBaseWidget::ComputeShouldAccelerate()
+{
+ return gfx::gfxConfig::IsEnabled(gfx::Feature::HW_COMPOSITING) &&
+ WidgetTypeSupportsAcceleration();
+}
+
+bool
+nsBaseWidget::UseAPZ()
+{
+ return (gfxPlatform::AsyncPanZoomEnabled() &&
+ (WindowType() == eWindowType_toplevel || WindowType() == eWindowType_child));
+}
+
+void nsBaseWidget::CreateCompositor()
+{
+ LayoutDeviceIntRect rect = GetBounds();
+ CreateCompositor(rect.width, rect.height);
+}
+
+already_AddRefed<GeckoContentController>
+nsBaseWidget::CreateRootContentController()
+{
+ RefPtr<GeckoContentController> controller = new ChromeProcessController(this, mAPZEventState, mAPZC);
+ return controller.forget();
+}
+
+void nsBaseWidget::ConfigureAPZCTreeManager()
+{
+ MOZ_ASSERT(mAPZC);
+
+ ConfigureAPZControllerThread();
+
+ mAPZC->SetDPI(GetDPI());
+
+ RefPtr<IAPZCTreeManager> treeManager = mAPZC; // for capture by the lambdas
+
+ ContentReceivedInputBlockCallback callback(
+ [treeManager](const ScrollableLayerGuid& aGuid,
+ uint64_t aInputBlockId,
+ bool aPreventDefault)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ APZThreadUtils::RunOnControllerThread(NewRunnableMethod
+ <uint64_t, bool>(treeManager,
+ &IAPZCTreeManager::ContentReceivedInputBlock,
+ aInputBlockId,
+ aPreventDefault));
+ });
+ mAPZEventState = new APZEventState(this, mozilla::Move(callback));
+
+ mSetAllowedTouchBehaviorCallback = [treeManager](uint64_t aInputBlockId,
+ const nsTArray<TouchBehaviorFlags>& aFlags)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ APZThreadUtils::RunOnControllerThread(NewRunnableMethod
+ <uint64_t,
+ StoreCopyPassByLRef<nsTArray<TouchBehaviorFlags>>>(treeManager,
+ &IAPZCTreeManager::SetAllowedTouchBehavior,
+ aInputBlockId, aFlags));
+ };
+
+ mRootContentController = CreateRootContentController();
+ if (mRootContentController) {
+ mCompositorSession->SetContentController(mRootContentController);
+ }
+
+ // When APZ is enabled, we can actually enable raw touch events because we
+ // have code that can deal with them properly. If APZ is not enabled, this
+ // function doesn't get called.
+ if (Preferences::GetInt("dom.w3c_touch_events.enabled", 0) ||
+ Preferences::GetBool("dom.w3c_pointer_events.enabled", false)) {
+ RegisterTouchWindow();
+ }
+}
+
+void nsBaseWidget::ConfigureAPZControllerThread()
+{
+ // By default the controller thread is the main thread.
+ APZThreadUtils::SetControllerThread(MessageLoop::current());
+}
+
+void
+nsBaseWidget::SetConfirmedTargetAPZC(uint64_t aInputBlockId,
+ const nsTArray<ScrollableLayerGuid>& aTargets) const
+{
+ APZThreadUtils::RunOnControllerThread(NewRunnableMethod
+ <uint64_t, StoreCopyPassByRRef<nsTArray<ScrollableLayerGuid>>>(mAPZC,
+ &IAPZCTreeManager::SetTargetAPZC,
+ aInputBlockId, aTargets));
+}
+
+void
+nsBaseWidget::UpdateZoomConstraints(const uint32_t& aPresShellId,
+ const FrameMetrics::ViewID& aViewId,
+ const Maybe<ZoomConstraints>& aConstraints)
+{
+ if (!mCompositorSession || !mAPZC) {
+ if (mInitialZoomConstraints) {
+ MOZ_ASSERT(mInitialZoomConstraints->mPresShellID == aPresShellId);
+ MOZ_ASSERT(mInitialZoomConstraints->mViewID == aViewId);
+ if (!aConstraints) {
+ mInitialZoomConstraints.reset();
+ }
+ }
+
+ if (aConstraints) {
+ // We have some constraints, but the compositor and APZC aren't created yet.
+ // Save these so we can use them later.
+ mInitialZoomConstraints = Some(InitialZoomConstraints(aPresShellId, aViewId, aConstraints.ref()));
+ }
+ return;
+ }
+ uint64_t layersId = mCompositorSession->RootLayerTreeId();
+ mAPZC->UpdateZoomConstraints(ScrollableLayerGuid(layersId, aPresShellId, aViewId),
+ aConstraints);
+}
+
+bool
+nsBaseWidget::AsyncPanZoomEnabled() const
+{
+ return !!mAPZC;
+}
+
+nsEventStatus
+nsBaseWidget::ProcessUntransformedAPZEvent(WidgetInputEvent* aEvent,
+ const ScrollableLayerGuid& aGuid,
+ uint64_t aInputBlockId,
+ nsEventStatus aApzResponse)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ InputAPZContext context(aGuid, aInputBlockId, aApzResponse);
+
+ // If this is an event that the APZ has targeted to an APZC in the root
+ // process, apply that APZC's callback-transform before dispatching the
+ // event. If the event is instead targeted to an APZC in the child process,
+ // the transform will be applied in the child process before dispatching
+ // the event there (see e.g. TabChild::RecvRealTouchEvent()).
+ if (aGuid.mLayersId == mCompositorSession->RootLayerTreeId()) {
+ APZCCallbackHelper::ApplyCallbackTransform(*aEvent, aGuid,
+ GetDefaultScale());
+ }
+
+ // Make a copy of the original event for the APZCCallbackHelper helpers that
+ // we call later, because the event passed to DispatchEvent can get mutated in
+ // ways that we don't want (i.e. touch points can get stripped out).
+ nsEventStatus status;
+ UniquePtr<WidgetEvent> original(aEvent->Duplicate());
+ DispatchEvent(aEvent, status);
+
+ if (mAPZC && !context.WasRoutedToChildProcess() && aInputBlockId) {
+ // EventStateManager did not route the event into the child process.
+ // It's safe to communicate to APZ that the event has been processed.
+ // TODO: Eventually we'll be able to move the SendSetTargetAPZCNotification
+ // call into APZEventState::Process*Event() as well.
+ if (WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent()) {
+ if (touchEvent->mMessage == eTouchStart) {
+ if (gfxPrefs::TouchActionEnabled()) {
+ APZCCallbackHelper::SendSetAllowedTouchBehaviorNotification(this,
+ GetDocument(), *(original->AsTouchEvent()), aInputBlockId,
+ mSetAllowedTouchBehaviorCallback);
+ }
+ APZCCallbackHelper::SendSetTargetAPZCNotification(this, GetDocument(),
+ *(original->AsTouchEvent()), aGuid, aInputBlockId);
+ }
+ mAPZEventState->ProcessTouchEvent(*touchEvent, aGuid, aInputBlockId,
+ aApzResponse, status);
+ } else if (WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent()) {
+ MOZ_ASSERT(wheelEvent->mFlags.mHandledByAPZ);
+ APZCCallbackHelper::SendSetTargetAPZCNotification(this, GetDocument(),
+ *(original->AsWheelEvent()), aGuid, aInputBlockId);
+ if (wheelEvent->mCanTriggerSwipe) {
+ ReportSwipeStarted(aInputBlockId, wheelEvent->TriggersSwipe());
+ }
+ mAPZEventState->ProcessWheelEvent(*wheelEvent, aGuid, aInputBlockId);
+ } else if (WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent()) {
+ MOZ_ASSERT(mouseEvent->mFlags.mHandledByAPZ);
+ APZCCallbackHelper::SendSetTargetAPZCNotification(this, GetDocument(),
+ *(original->AsMouseEvent()), aGuid, aInputBlockId);
+ mAPZEventState->ProcessMouseEvent(*mouseEvent, aGuid, aInputBlockId);
+ }
+ }
+
+ return status;
+}
+
+class DispatchWheelEventOnMainThread : public Runnable
+{
+public:
+ DispatchWheelEventOnMainThread(const ScrollWheelInput& aWheelInput,
+ nsBaseWidget* aWidget,
+ nsEventStatus aAPZResult,
+ uint64_t aInputBlockId,
+ ScrollableLayerGuid aGuid)
+ : mWheelInput(aWheelInput)
+ , mWidget(aWidget)
+ , mAPZResult(aAPZResult)
+ , mInputBlockId(aInputBlockId)
+ , mGuid(aGuid)
+ {
+ }
+
+ NS_IMETHOD Run() override
+ {
+ WidgetWheelEvent wheelEvent = mWheelInput.ToWidgetWheelEvent(mWidget);
+ mWidget->ProcessUntransformedAPZEvent(&wheelEvent, mGuid, mInputBlockId, mAPZResult);
+ return NS_OK;
+ }
+
+private:
+ ScrollWheelInput mWheelInput;
+ nsBaseWidget* mWidget;
+ nsEventStatus mAPZResult;
+ uint64_t mInputBlockId;
+ ScrollableLayerGuid mGuid;
+};
+
+class DispatchWheelInputOnControllerThread : public Runnable
+{
+public:
+ DispatchWheelInputOnControllerThread(const WidgetWheelEvent& aWheelEvent,
+ IAPZCTreeManager* aAPZC,
+ nsBaseWidget* aWidget)
+ : mMainMessageLoop(MessageLoop::current())
+ , mWheelInput(aWheelEvent)
+ , mAPZC(aAPZC)
+ , mWidget(aWidget)
+ , mInputBlockId(0)
+ {
+ }
+
+ NS_IMETHOD Run() override
+ {
+ nsEventStatus result = mAPZC->ReceiveInputEvent(mWheelInput, &mGuid, &mInputBlockId);
+ if (result == nsEventStatus_eConsumeNoDefault) {
+ return NS_OK;
+ }
+ RefPtr<Runnable> r = new DispatchWheelEventOnMainThread(mWheelInput, mWidget, result, mInputBlockId, mGuid);
+ mMainMessageLoop->PostTask(r.forget());
+ return NS_OK;
+ }
+
+private:
+ MessageLoop* mMainMessageLoop;
+ ScrollWheelInput mWheelInput;
+ RefPtr<IAPZCTreeManager> mAPZC;
+ nsBaseWidget* mWidget;
+ uint64_t mInputBlockId;
+ ScrollableLayerGuid mGuid;
+};
+
+void
+nsBaseWidget::DispatchTouchInput(MultiTouchInput& aInput)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (mAPZC) {
+ MOZ_ASSERT(APZThreadUtils::IsControllerThread());
+ uint64_t inputBlockId = 0;
+ ScrollableLayerGuid guid;
+
+ nsEventStatus result = mAPZC->ReceiveInputEvent(aInput, &guid, &inputBlockId);
+ if (result == nsEventStatus_eConsumeNoDefault) {
+ return;
+ }
+
+ WidgetTouchEvent event = aInput.ToWidgetTouchEvent(this);
+ ProcessUntransformedAPZEvent(&event, guid, inputBlockId, result);
+ } else {
+ WidgetTouchEvent event = aInput.ToWidgetTouchEvent(this);
+
+ nsEventStatus status;
+ DispatchEvent(&event, status);
+ }
+}
+
+nsEventStatus
+nsBaseWidget::DispatchInputEvent(WidgetInputEvent* aEvent)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (mAPZC) {
+ if (APZThreadUtils::IsControllerThread()) {
+ uint64_t inputBlockId = 0;
+ ScrollableLayerGuid guid;
+
+ nsEventStatus result = mAPZC->ReceiveInputEvent(*aEvent, &guid, &inputBlockId);
+ if (result == nsEventStatus_eConsumeNoDefault) {
+ return result;
+ }
+ return ProcessUntransformedAPZEvent(aEvent, guid, inputBlockId, result);
+ } else {
+ WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
+ if (wheelEvent) {
+ RefPtr<Runnable> r = new DispatchWheelInputOnControllerThread(*wheelEvent, mAPZC, this);
+ APZThreadUtils::RunOnControllerThread(r.forget());
+ return nsEventStatus_eConsumeDoDefault;
+ }
+ MOZ_CRASH();
+ }
+ }
+
+ nsEventStatus status;
+ DispatchEvent(aEvent, status);
+ return status;
+}
+
+void
+nsBaseWidget::DispatchEventToAPZOnly(mozilla::WidgetInputEvent* aEvent)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (mAPZC) {
+ MOZ_ASSERT(APZThreadUtils::IsControllerThread());
+ uint64_t inputBlockId = 0;
+ ScrollableLayerGuid guid;
+ mAPZC->ReceiveInputEvent(*aEvent, &guid, &inputBlockId);
+ }
+}
+
+nsIDocument*
+nsBaseWidget::GetDocument() const
+{
+ if (mWidgetListener) {
+ if (nsIPresShell* presShell = mWidgetListener->GetPresShell()) {
+ return presShell->GetDocument();
+ }
+ }
+ return nullptr;
+}
+
+void nsBaseWidget::CreateCompositorVsyncDispatcher()
+{
+ // Parent directly listens to the vsync source whereas
+ // child process communicate via IPC
+ // Should be called AFTER gfxPlatform is initialized
+ if (XRE_IsParentProcess()) {
+ mCompositorVsyncDispatcher = new CompositorVsyncDispatcher();
+ }
+}
+
+CompositorVsyncDispatcher*
+nsBaseWidget::GetCompositorVsyncDispatcher()
+{
+ return mCompositorVsyncDispatcher;
+}
+
+void nsBaseWidget::CreateCompositor(int aWidth, int aHeight)
+{
+ // This makes sure that gfxPlatforms gets initialized if it hasn't by now.
+ gfxPlatform::GetPlatform();
+
+ MOZ_ASSERT(gfxPlatform::UsesOffMainThreadCompositing(),
+ "This function assumes OMTC");
+
+ MOZ_ASSERT(!mCompositorSession && !mCompositorBridgeChild,
+ "Should have properly cleaned up the previous PCompositor pair beforehand");
+
+ if (mCompositorBridgeChild) {
+ mCompositorBridgeChild->Destroy();
+ }
+
+ // Recreating this is tricky, as we may still have an old and we need
+ // to make sure it's properly destroyed by calling DestroyCompositor!
+
+ // If we've already received a shutdown notification, don't try
+ // create a new compositor.
+ if (!mShutdownObserver) {
+ return;
+ }
+
+ CreateCompositorVsyncDispatcher();
+
+ RefPtr<ClientLayerManager> lm = new ClientLayerManager(this);
+
+ bool useAPZ = UseAPZ();
+
+ gfx::GPUProcessManager* gpu = gfx::GPUProcessManager::Get();
+ mCompositorSession = gpu->CreateTopLevelCompositor(
+ this,
+ lm,
+ GetDefaultScale(),
+ useAPZ,
+ UseExternalCompositingSurface(),
+ gfx::IntSize(aWidth, aHeight));
+ mCompositorBridgeChild = mCompositorSession->GetCompositorBridgeChild();
+ mCompositorWidgetDelegate = mCompositorSession->GetCompositorWidgetDelegate();
+
+ if (useAPZ) {
+ mAPZC = mCompositorSession->GetAPZCTreeManager();
+ ConfigureAPZCTreeManager();
+ } else {
+ mAPZC = nullptr;
+ }
+
+ if (mInitialZoomConstraints) {
+ UpdateZoomConstraints(mInitialZoomConstraints->mPresShellID,
+ mInitialZoomConstraints->mViewID,
+ Some(mInitialZoomConstraints->mConstraints));
+ mInitialZoomConstraints.reset();
+ }
+
+ ShadowLayerForwarder* lf = lm->AsShadowForwarder();
+ // As long as we are creating a ClientLayerManager above lf must be non-null.
+ MOZ_ASSERT(lf);
+
+ if (lf) {
+ TextureFactoryIdentifier textureFactoryIdentifier;
+ PLayerTransactionChild* shadowManager = nullptr;
+
+ nsTArray<LayersBackend> backendHints;
+ gfxPlatform::GetPlatform()->GetCompositorBackends(ComputeShouldAccelerate(), backendHints);
+
+ bool success = false;
+ if (!backendHints.IsEmpty()) {
+ shadowManager = mCompositorBridgeChild->SendPLayerTransactionConstructor(
+ backendHints, 0, &textureFactoryIdentifier, &success);
+ }
+
+ if (!success) {
+ NS_WARNING("Failed to create an OMT compositor.");
+ DestroyCompositor();
+ mLayerManager = nullptr;
+ return;
+ }
+
+ lf->SetShadowManager(shadowManager);
+ if (ClientLayerManager* clm = lm->AsClientLayerManager()) {
+ clm->UpdateTextureFactoryIdentifier(textureFactoryIdentifier);
+ }
+ // Some popup or transparent widgets may use a different backend than the
+ // compositors used with ImageBridge and VR (and more generally web content).
+ if (WidgetTypeSupportsAcceleration()) {
+ ImageBridgeChild::IdentifyCompositorTextureHost(textureFactoryIdentifier);
+ gfx::VRManagerChild::IdentifyTextureHost(textureFactoryIdentifier);
+ }
+ }
+
+ WindowUsesOMTC();
+
+ mLayerManager = lm.forget();
+
+ // Only track compositors for top-level windows, since other window types
+ // may use the basic compositor. Except on the OS X - see bug 1306383
+#if defined(XP_MACOSX)
+ bool getCompositorFromThisWindow = true;
+#else
+ bool getCompositorFromThisWindow = (mWindowType == eWindowType_toplevel);
+#endif
+
+ if (getCompositorFromThisWindow) {
+ gfxPlatform::GetPlatform()->NotifyCompositorCreated(mLayerManager->GetCompositorBackendType());
+ }
+}
+
+void nsBaseWidget::NotifyRemoteCompositorSessionLost(CompositorSession* aSession)
+{
+ MOZ_ASSERT(aSession == mCompositorSession);
+ DestroyLayerManager();
+}
+
+bool nsBaseWidget::ShouldUseOffMainThreadCompositing()
+{
+ return gfxPlatform::UsesOffMainThreadCompositing();
+}
+
+LayerManager* nsBaseWidget::GetLayerManager(PLayerTransactionChild* aShadowManager,
+ LayersBackend aBackendHint,
+ LayerManagerPersistence aPersistence)
+{
+ if (!mLayerManager) {
+ if (!mShutdownObserver) {
+ // We are shutting down, do not try to re-create a LayerManager
+ return nullptr;
+ }
+ // Try to use an async compositor first, if possible
+ if (ShouldUseOffMainThreadCompositing()) {
+ // e10s uses the parameter to pass in the shadow manager from the TabChild
+ // so we don't expect to see it there since this doesn't support e10s.
+ NS_ASSERTION(aShadowManager == nullptr, "Async Compositor not supported with e10s");
+ CreateCompositor();
+ }
+
+ if (!mLayerManager) {
+ mLayerManager = CreateBasicLayerManager();
+ }
+ }
+ return mLayerManager;
+}
+
+LayerManager* nsBaseWidget::CreateBasicLayerManager()
+{
+ return new BasicLayerManager(this);
+}
+
+CompositorBridgeChild* nsBaseWidget::GetRemoteRenderer()
+{
+ return mCompositorBridgeChild;
+}
+
+already_AddRefed<gfx::DrawTarget>
+nsBaseWidget::StartRemoteDrawing()
+{
+ return nullptr;
+}
+
+uint32_t
+nsBaseWidget::GetGLFrameBufferFormat()
+{
+ return LOCAL_GL_RGBA;
+}
+
+//-------------------------------------------------------------------------
+//
+// Destroy the window
+//
+//-------------------------------------------------------------------------
+void nsBaseWidget::OnDestroy()
+{
+ if (mTextEventDispatcher) {
+ mTextEventDispatcher->OnDestroyWidget();
+ // Don't release it until this widget actually released because after this
+ // is called, TextEventDispatcher() may create it again.
+ }
+
+ // If this widget is being destroyed, let the APZ code know to drop references
+ // to this widget. Callers of this function all should be holding a deathgrip
+ // on this widget already.
+ ReleaseContentController();
+}
+
+NS_IMETHODIMP nsBaseWidget::MoveClient(double aX, double aY)
+{
+ LayoutDeviceIntPoint clientOffset(GetClientOffset());
+
+ // GetClientOffset returns device pixels; scale back to desktop pixels
+ // if that's what this widget uses for the Move/Resize APIs
+ if (BoundsUseDesktopPixels()) {
+ DesktopPoint desktopOffset = clientOffset / GetDesktopToDeviceScale();
+ return Move(aX - desktopOffset.x, aY - desktopOffset.y);
+ } else {
+ return Move(aX - clientOffset.x, aY - clientOffset.y);
+ }
+}
+
+NS_IMETHODIMP nsBaseWidget::ResizeClient(double aWidth,
+ double aHeight,
+ bool aRepaint)
+{
+ NS_ASSERTION((aWidth >=0) , "Negative width passed to ResizeClient");
+ NS_ASSERTION((aHeight >=0), "Negative height passed to ResizeClient");
+
+ LayoutDeviceIntRect clientBounds = GetClientBounds();
+
+ // GetClientBounds and mBounds are device pixels; scale back to desktop pixels
+ // if that's what this widget uses for the Move/Resize APIs
+ if (BoundsUseDesktopPixels()) {
+ DesktopSize desktopDelta =
+ (LayoutDeviceIntSize(mBounds.width, mBounds.height) -
+ clientBounds.Size()) / GetDesktopToDeviceScale();
+ return Resize(aWidth + desktopDelta.width, aHeight + desktopDelta.height,
+ aRepaint);
+ } else {
+ return Resize(mBounds.width + (aWidth - clientBounds.width),
+ mBounds.height + (aHeight - clientBounds.height), aRepaint);
+ }
+}
+
+NS_IMETHODIMP nsBaseWidget::ResizeClient(double aX,
+ double aY,
+ double aWidth,
+ double aHeight,
+ bool aRepaint)
+{
+ NS_ASSERTION((aWidth >=0) , "Negative width passed to ResizeClient");
+ NS_ASSERTION((aHeight >=0), "Negative height passed to ResizeClient");
+
+ LayoutDeviceIntRect clientBounds = GetClientBounds();
+ LayoutDeviceIntPoint clientOffset = GetClientOffset();
+
+ if (BoundsUseDesktopPixels()) {
+ DesktopToLayoutDeviceScale scale = GetDesktopToDeviceScale();
+ DesktopPoint desktopOffset = clientOffset / scale;
+ DesktopSize desktopDelta =
+ (LayoutDeviceIntSize(mBounds.width, mBounds.height) -
+ clientBounds.Size()) / scale;
+ return Resize(aX - desktopOffset.x, aY - desktopOffset.y,
+ aWidth + desktopDelta.width, aHeight + desktopDelta.height,
+ aRepaint);
+ } else {
+ return Resize(aX - clientOffset.x, aY - clientOffset.y,
+ aWidth + mBounds.width - clientBounds.width,
+ aHeight + mBounds.height - clientBounds.height,
+ aRepaint);
+ }
+}
+
+//-------------------------------------------------------------------------
+//
+// Bounds
+//
+//-------------------------------------------------------------------------
+
+/**
+* If the implementation of nsWindow supports borders this method MUST be overridden
+*
+**/
+LayoutDeviceIntRect
+nsBaseWidget::GetClientBounds()
+{
+ return GetBounds();
+}
+
+/**
+* If the implementation of nsWindow supports borders this method MUST be overridden
+*
+**/
+LayoutDeviceIntRect
+nsBaseWidget::GetBounds()
+{
+ return mBounds;
+}
+
+/**
+* If the implementation of nsWindow uses a local coordinate system within the window,
+* this method must be overridden
+*
+**/
+LayoutDeviceIntRect
+nsBaseWidget::GetScreenBounds()
+{
+ return GetBounds();
+}
+
+nsresult
+nsBaseWidget::GetRestoredBounds(LayoutDeviceIntRect& aRect)
+{
+ if (SizeMode() != nsSizeMode_Normal) {
+ return NS_ERROR_FAILURE;
+ }
+ aRect = GetScreenBounds();
+ return NS_OK;
+}
+
+LayoutDeviceIntPoint
+nsBaseWidget::GetClientOffset()
+{
+ return LayoutDeviceIntPoint(0, 0);
+}
+
+NS_IMETHODIMP
+nsBaseWidget::SetNonClientMargins(LayoutDeviceIntMargin &margins)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+uint32_t nsBaseWidget::GetMaxTouchPoints() const
+{
+ return 0;
+}
+
+NS_IMETHODIMP
+nsBaseWidget::GetAttention(int32_t aCycleCount) {
+ return NS_OK;
+}
+
+bool
+nsBaseWidget::HasPendingInputEvent()
+{
+ return false;
+}
+
+NS_IMETHODIMP
+nsBaseWidget::SetIcon(const nsAString&)
+{
+ return NS_OK;
+}
+
+bool
+nsBaseWidget::ShowsResizeIndicator(LayoutDeviceIntRect* aResizerRect)
+{
+ return false;
+}
+
+/**
+ * Modifies aFile to point at an icon file with the given name and suffix. The
+ * suffix may correspond to a file extension with leading '.' if appropriate.
+ * Returns true if the icon file exists and can be read.
+ */
+static bool
+ResolveIconNameHelper(nsIFile *aFile,
+ const nsAString &aIconName,
+ const nsAString &aIconSuffix)
+{
+ aFile->Append(NS_LITERAL_STRING("icons"));
+ aFile->Append(NS_LITERAL_STRING("default"));
+ aFile->Append(aIconName + aIconSuffix);
+
+ bool readable;
+ return NS_SUCCEEDED(aFile->IsReadable(&readable)) && readable;
+}
+
+/**
+ * Resolve the given icon name into a local file object. This method is
+ * intended to be called by subclasses of nsBaseWidget. aIconSuffix is a
+ * platform specific icon file suffix (e.g., ".ico" under Win32).
+ *
+ * If no file is found matching the given parameters, then null is returned.
+ */
+void
+nsBaseWidget::ResolveIconName(const nsAString &aIconName,
+ const nsAString &aIconSuffix,
+ nsIFile **aResult)
+{
+ *aResult = nullptr;
+
+ nsCOMPtr<nsIProperties> dirSvc = do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
+ if (!dirSvc)
+ return;
+
+ // first check auxilary chrome directories
+
+ nsCOMPtr<nsISimpleEnumerator> dirs;
+ dirSvc->Get(NS_APP_CHROME_DIR_LIST, NS_GET_IID(nsISimpleEnumerator),
+ getter_AddRefs(dirs));
+ if (dirs) {
+ bool hasMore;
+ while (NS_SUCCEEDED(dirs->HasMoreElements(&hasMore)) && hasMore) {
+ nsCOMPtr<nsISupports> element;
+ dirs->GetNext(getter_AddRefs(element));
+ if (!element)
+ continue;
+ nsCOMPtr<nsIFile> file = do_QueryInterface(element);
+ if (!file)
+ continue;
+ if (ResolveIconNameHelper(file, aIconName, aIconSuffix)) {
+ NS_ADDREF(*aResult = file);
+ return;
+ }
+ }
+ }
+
+ // then check the main app chrome directory
+
+ nsCOMPtr<nsIFile> file;
+ dirSvc->Get(NS_APP_CHROME_DIR, NS_GET_IID(nsIFile),
+ getter_AddRefs(file));
+ if (file && ResolveIconNameHelper(file, aIconName, aIconSuffix))
+ NS_ADDREF(*aResult = file);
+}
+
+NS_IMETHODIMP
+nsBaseWidget::BeginResizeDrag(WidgetGUIEvent* aEvent,
+ int32_t aHorizontal,
+ int32_t aVertical)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsBaseWidget::BeginMoveDrag(WidgetMouseEvent* aEvent)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+void nsBaseWidget::SetSizeConstraints(const SizeConstraints& aConstraints)
+{
+ mSizeConstraints = aConstraints;
+ // We can't ensure that the size is honored at this point because we're
+ // probably in the middle of a reflow.
+}
+
+const widget::SizeConstraints nsBaseWidget::GetSizeConstraints()
+{
+ return mSizeConstraints;
+}
+
+// static
+nsIRollupListener*
+nsBaseWidget::GetActiveRollupListener()
+{
+ // If set, then this is likely an <html:select> dropdown.
+ if (gRollupListener)
+ return gRollupListener;
+
+ return nsXULPopupManager::GetInstance();
+}
+
+void
+nsBaseWidget::NotifyWindowDestroyed()
+{
+ if (!mWidgetListener)
+ return;
+
+ nsCOMPtr<nsIXULWindow> window = mWidgetListener->GetXULWindow();
+ nsCOMPtr<nsIBaseWindow> xulWindow(do_QueryInterface(window));
+ if (xulWindow) {
+ xulWindow->Destroy();
+ }
+}
+
+void
+nsBaseWidget::NotifySizeMoveDone()
+{
+ if (!mWidgetListener || mWidgetListener->GetXULWindow())
+ return;
+
+ nsIPresShell* presShell = mWidgetListener->GetPresShell();
+ if (presShell) {
+ presShell->WindowSizeMoveDone();
+ }
+}
+
+void
+nsBaseWidget::NotifyWindowMoved(int32_t aX, int32_t aY)
+{
+ if (mWidgetListener) {
+ mWidgetListener->WindowMoved(this, aX, aY);
+ }
+
+ if (mIMEHasFocus && GetIMEUpdatePreference().WantPositionChanged()) {
+ NotifyIME(IMENotification(IMEMessage::NOTIFY_IME_OF_POSITION_CHANGE));
+ }
+}
+
+void
+nsBaseWidget::NotifySysColorChanged()
+{
+ if (!mWidgetListener || mWidgetListener->GetXULWindow())
+ return;
+
+ nsIPresShell* presShell = mWidgetListener->GetPresShell();
+ if (presShell) {
+ presShell->SysColorChanged();
+ }
+}
+
+void
+nsBaseWidget::NotifyThemeChanged()
+{
+ if (!mWidgetListener || mWidgetListener->GetXULWindow())
+ return;
+
+ nsIPresShell* presShell = mWidgetListener->GetPresShell();
+ if (presShell) {
+ presShell->ThemeChanged();
+ }
+}
+
+void
+nsBaseWidget::NotifyUIStateChanged(UIStateChangeType aShowAccelerators,
+ UIStateChangeType aShowFocusRings)
+{
+ if (nsIDocument* doc = GetDocument()) {
+ nsPIDOMWindowOuter* win = doc->GetWindow();
+ if (win) {
+ win->SetKeyboardIndicators(aShowAccelerators, aShowFocusRings);
+ }
+ }
+}
+
+NS_IMETHODIMP
+nsBaseWidget::NotifyIME(const IMENotification& aIMENotification)
+{
+ switch (aIMENotification.mMessage) {
+ case REQUEST_TO_COMMIT_COMPOSITION:
+ case REQUEST_TO_CANCEL_COMPOSITION:
+ // Currently, if native IME handler doesn't use TextEventDispatcher,
+ // the request may be notified to mTextEventDispatcher or native IME
+ // directly. Therefore, if mTextEventDispatcher has a composition,
+ // the request should be handled by the mTextEventDispatcher.
+ if (mTextEventDispatcher && mTextEventDispatcher->IsComposing()) {
+ return mTextEventDispatcher->NotifyIME(aIMENotification);
+ }
+ // Otherwise, it should be handled by native IME.
+ return NotifyIMEInternal(aIMENotification);
+ default: {
+ if (aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS) {
+ mIMEHasFocus = true;
+ }
+ EnsureTextEventDispatcher();
+ // If the platform specific widget uses TextEventDispatcher for handling
+ // native IME and keyboard events, IME event handler should be notified
+ // of the notification via TextEventDispatcher. Otherwise, on the other
+ // platforms which have not used TextEventDispatcher yet, IME event
+ // handler should be notified by the old path (NotifyIMEInternal).
+ nsresult rv = mTextEventDispatcher->NotifyIME(aIMENotification);
+ nsresult rv2 = NotifyIMEInternal(aIMENotification);
+ if (aIMENotification.mMessage == NOTIFY_IME_OF_BLUR) {
+ mIMEHasFocus = false;
+ }
+ return rv2 == NS_ERROR_NOT_IMPLEMENTED ? rv : rv2;
+ }
+ }
+}
+
+void
+nsBaseWidget::EnsureTextEventDispatcher()
+{
+ if (mTextEventDispatcher) {
+ return;
+ }
+ mTextEventDispatcher = new TextEventDispatcher(this);
+}
+
+NS_IMETHODIMP_(nsIWidget::TextEventDispatcher*)
+nsBaseWidget::GetTextEventDispatcher()
+{
+ EnsureTextEventDispatcher();
+ return mTextEventDispatcher;
+}
+
+void*
+nsBaseWidget::GetPseudoIMEContext()
+{
+ TextEventDispatcher* dispatcher = GetTextEventDispatcher();
+ if (!dispatcher) {
+ return nullptr;
+ }
+ return dispatcher->GetPseudoIMEContext();
+}
+
+NS_IMETHODIMP_(TextEventDispatcherListener*)
+nsBaseWidget::GetNativeTextEventDispatcherListener()
+{
+ // TODO: If all platforms supported use of TextEventDispatcher for handling
+ // native IME and keyboard events, this method should be removed since
+ // in such case, this is overridden by all the subclasses.
+ return nullptr;
+}
+
+void
+nsBaseWidget::ZoomToRect(const uint32_t& aPresShellId,
+ const FrameMetrics::ViewID& aViewId,
+ const CSSRect& aRect,
+ const uint32_t& aFlags)
+{
+ if (!mCompositorSession || !mAPZC) {
+ return;
+ }
+ uint64_t layerId = mCompositorSession->RootLayerTreeId();
+ mAPZC->ZoomToRect(ScrollableLayerGuid(layerId, aPresShellId, aViewId), aRect, aFlags);
+}
+
+#ifdef ACCESSIBILITY
+
+#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
+// defined in nsAppRunner.cpp
+extern const char* kAccessibilityLastRunDatePref;
+
+static inline uint32_t
+PRTimeToSeconds(PRTime t_usec)
+{
+ PRTime usec_per_sec = PR_USEC_PER_SEC;
+ return uint32_t(t_usec /= usec_per_sec);
+}
+#endif
+
+a11y::Accessible*
+nsBaseWidget::GetRootAccessible()
+{
+ NS_ENSURE_TRUE(mWidgetListener, nullptr);
+
+ nsIPresShell* presShell = mWidgetListener->GetPresShell();
+ NS_ENSURE_TRUE(presShell, nullptr);
+
+ // If container is null then the presshell is not active. This often happens
+ // when a preshell is being held onto for fastback.
+ nsPresContext* presContext = presShell->GetPresContext();
+ NS_ENSURE_TRUE(presContext->GetContainerWeak(), nullptr);
+
+ // Accessible creation might be not safe so use IsSafeToRunScript to
+ // make sure it's not created at unsafe times.
+ nsAccessibilityService* accService = GetOrCreateAccService();
+ if (accService) {
+#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
+ if (!mAccessibilityInUseFlag) {
+ mAccessibilityInUseFlag = true;
+ uint32_t now = PRTimeToSeconds(PR_Now());
+ Preferences::SetInt(kAccessibilityLastRunDatePref, now);
+ }
+#endif
+ return accService->GetRootDocumentAccessible(presShell, nsContentUtils::IsSafeToRunScript());
+ }
+
+ return nullptr;
+}
+
+#endif // ACCESSIBILITY
+
+void
+nsBaseWidget::StartAsyncScrollbarDrag(const AsyncDragMetrics& aDragMetrics)
+{
+ if (!AsyncPanZoomEnabled()) {
+ return;
+ }
+
+ MOZ_ASSERT(XRE_IsParentProcess() && mCompositorSession);
+
+ int layersId = mCompositorSession->RootLayerTreeId();;
+ ScrollableLayerGuid guid(layersId, aDragMetrics.mPresShellId, aDragMetrics.mViewId);
+
+ APZThreadUtils::RunOnControllerThread(NewRunnableMethod
+ <ScrollableLayerGuid, AsyncDragMetrics>(mAPZC,
+ &IAPZCTreeManager::StartScrollbarDrag,
+ guid, aDragMetrics));
+}
+
+already_AddRefed<nsIScreen>
+nsBaseWidget::GetWidgetScreen()
+{
+ nsCOMPtr<nsIScreenManager> screenManager;
+ screenManager = do_GetService("@mozilla.org/gfx/screenmanager;1");
+ if (!screenManager) {
+ return nullptr;
+ }
+
+ LayoutDeviceIntRect bounds = GetScreenBounds();
+ DesktopIntRect deskBounds = RoundedToInt(bounds / GetDesktopToDeviceScale());
+ nsCOMPtr<nsIScreen> screen;
+ screenManager->ScreenForRect(deskBounds.x, deskBounds.y,
+ deskBounds.width, deskBounds.height,
+ getter_AddRefs(screen));
+ return screen.forget();
+}
+
+nsresult
+nsIWidget::SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint, bool aLongTap,
+ nsIObserver* aObserver)
+{
+ AutoObserverNotifier notifier(aObserver, "touchtap");
+
+ if (sPointerIdCounter > TOUCH_INJECT_MAX_POINTS) {
+ sPointerIdCounter = 0;
+ }
+ int pointerId = sPointerIdCounter;
+ sPointerIdCounter++;
+ nsresult rv = SynthesizeNativeTouchPoint(pointerId, TOUCH_CONTACT,
+ aPoint, 1.0, 90, nullptr);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ if (!aLongTap) {
+ return SynthesizeNativeTouchPoint(pointerId, TOUCH_REMOVE,
+ aPoint, 0, 0, nullptr);
+ }
+
+ // initiate a long tap
+ int elapse = Preferences::GetInt("ui.click_hold_context_menus.delay",
+ TOUCH_INJECT_LONG_TAP_DEFAULT_MSEC);
+ if (!mLongTapTimer) {
+ mLongTapTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
+ if (NS_FAILED(rv)) {
+ SynthesizeNativeTouchPoint(pointerId, TOUCH_CANCEL,
+ aPoint, 0, 0, nullptr);
+ return NS_ERROR_UNEXPECTED;
+ }
+ // Windows requires recuring events, so we set this to a smaller window
+ // than the pref value.
+ int timeout = elapse;
+ if (timeout > TOUCH_INJECT_PUMP_TIMER_MSEC) {
+ timeout = TOUCH_INJECT_PUMP_TIMER_MSEC;
+ }
+ mLongTapTimer->InitWithFuncCallback(OnLongTapTimerCallback, this,
+ timeout,
+ nsITimer::TYPE_REPEATING_SLACK);
+ }
+
+ // If we already have a long tap pending, cancel it. We only allow one long
+ // tap to be active at a time.
+ if (mLongTapTouchPoint) {
+ SynthesizeNativeTouchPoint(mLongTapTouchPoint->mPointerId, TOUCH_CANCEL,
+ mLongTapTouchPoint->mPosition, 0, 0, nullptr);
+ }
+
+ mLongTapTouchPoint =
+ MakeUnique<LongTapInfo>(pointerId, aPoint,
+ TimeDuration::FromMilliseconds(elapse),
+ aObserver);
+ notifier.SkipNotification(); // we'll do it in the long-tap callback
+ return NS_OK;
+}
+
+// static
+void
+nsIWidget::OnLongTapTimerCallback(nsITimer* aTimer, void* aClosure)
+{
+ nsIWidget *self = static_cast<nsIWidget *>(aClosure);
+
+ if ((self->mLongTapTouchPoint->mStamp + self->mLongTapTouchPoint->mDuration) >
+ TimeStamp::Now()) {
+#ifdef XP_WIN
+ // Windows needs us to keep pumping feedback to the digitizer, so update
+ // the pointer id with the same position.
+ self->SynthesizeNativeTouchPoint(self->mLongTapTouchPoint->mPointerId,
+ TOUCH_CONTACT,
+ self->mLongTapTouchPoint->mPosition,
+ 1.0, 90, nullptr);
+#endif
+ return;
+ }
+
+ AutoObserverNotifier notifier(self->mLongTapTouchPoint->mObserver, "touchtap");
+
+ // finished, remove the touch point
+ self->mLongTapTimer->Cancel();
+ self->mLongTapTimer = nullptr;
+ self->SynthesizeNativeTouchPoint(self->mLongTapTouchPoint->mPointerId,
+ TOUCH_REMOVE,
+ self->mLongTapTouchPoint->mPosition,
+ 0, 0, nullptr);
+ self->mLongTapTouchPoint = nullptr;
+}
+
+nsresult
+nsIWidget::ClearNativeTouchSequence(nsIObserver* aObserver)
+{
+ AutoObserverNotifier notifier(aObserver, "cleartouch");
+
+ if (!mLongTapTimer) {
+ return NS_OK;
+ }
+ mLongTapTimer->Cancel();
+ mLongTapTimer = nullptr;
+ SynthesizeNativeTouchPoint(mLongTapTouchPoint->mPointerId, TOUCH_CANCEL,
+ mLongTapTouchPoint->mPosition, 0, 0, nullptr);
+ mLongTapTouchPoint = nullptr;
+ return NS_OK;
+}
+
+MultiTouchInput
+nsBaseWidget::UpdateSynthesizedTouchState(MultiTouchInput* aState,
+ uint32_t aTime,
+ mozilla::TimeStamp aTimeStamp,
+ uint32_t aPointerId,
+ TouchPointerState aPointerState,
+ LayoutDeviceIntPoint aPoint,
+ double aPointerPressure,
+ uint32_t aPointerOrientation)
+{
+ ScreenIntPoint pointerScreenPoint = ViewAs<ScreenPixel>(aPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForBounds);
+
+ // We can't dispatch *aState directly because (a) dispatching
+ // it might inadvertently modify it and (b) in the case of touchend or
+ // touchcancel events aState will hold the touches that are
+ // still down whereas the input dispatched needs to hold the removed
+ // touch(es). We use |inputToDispatch| for this purpose.
+ MultiTouchInput inputToDispatch;
+ inputToDispatch.mInputType = MULTITOUCH_INPUT;
+ inputToDispatch.mTime = aTime;
+ inputToDispatch.mTimeStamp = aTimeStamp;
+
+ int32_t index = aState->IndexOfTouch((int32_t)aPointerId);
+ if (aPointerState == TOUCH_CONTACT) {
+ if (index >= 0) {
+ // found an existing touch point, update it
+ SingleTouchData& point = aState->mTouches[index];
+ point.mScreenPoint = pointerScreenPoint;
+ point.mRotationAngle = (float)aPointerOrientation;
+ point.mForce = (float)aPointerPressure;
+ inputToDispatch.mType = MultiTouchInput::MULTITOUCH_MOVE;
+ } else {
+ // new touch point, add it
+ aState->mTouches.AppendElement(SingleTouchData(
+ (int32_t)aPointerId,
+ pointerScreenPoint,
+ ScreenSize(0, 0),
+ (float)aPointerOrientation,
+ (float)aPointerPressure));
+ inputToDispatch.mType = MultiTouchInput::MULTITOUCH_START;
+ }
+ inputToDispatch.mTouches = aState->mTouches;
+ } else {
+ MOZ_ASSERT(aPointerState == TOUCH_REMOVE || aPointerState == TOUCH_CANCEL);
+ // a touch point is being lifted, so remove it from the stored list
+ if (index >= 0) {
+ aState->mTouches.RemoveElementAt(index);
+ }
+ inputToDispatch.mType = (aPointerState == TOUCH_REMOVE
+ ? MultiTouchInput::MULTITOUCH_END
+ : MultiTouchInput::MULTITOUCH_CANCEL);
+ inputToDispatch.mTouches.AppendElement(SingleTouchData(
+ (int32_t)aPointerId,
+ pointerScreenPoint,
+ ScreenSize(0, 0),
+ (float)aPointerOrientation,
+ (float)aPointerPressure));
+ }
+
+ return inputToDispatch;
+}
+
+void
+nsBaseWidget::RegisterPluginWindowForRemoteUpdates()
+{
+#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
+ NS_NOTREACHED("nsBaseWidget::RegisterPluginWindowForRemoteUpdates not implemented!");
+ return;
+#else
+ MOZ_ASSERT(NS_IsMainThread());
+ void* id = GetNativeData(NS_NATIVE_PLUGIN_ID);
+ if (!id) {
+ NS_WARNING("This is not a valid native widget!");
+ return;
+ }
+ MOZ_ASSERT(sPluginWidgetList);
+ sPluginWidgetList->Put(id, this);
+#endif
+}
+
+void
+nsBaseWidget::UnregisterPluginWindowForRemoteUpdates()
+{
+#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
+ NS_NOTREACHED("nsBaseWidget::UnregisterPluginWindowForRemoteUpdates not implemented!");
+ return;
+#else
+ MOZ_ASSERT(NS_IsMainThread());
+ void* id = GetNativeData(NS_NATIVE_PLUGIN_ID);
+ if (!id) {
+ NS_WARNING("This is not a valid native widget!");
+ return;
+ }
+ MOZ_ASSERT(sPluginWidgetList);
+ sPluginWidgetList->Remove(id);
+#endif
+}
+
+// static
+nsIWidget*
+nsIWidget::LookupRegisteredPluginWindow(uintptr_t aWindowID)
+{
+#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
+ NS_NOTREACHED("nsBaseWidget::LookupRegisteredPluginWindow not implemented!");
+ return nullptr;
+#else
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(sPluginWidgetList);
+ return sPluginWidgetList->GetWeak((void*)aWindowID);
+#endif
+}
+
+// static
+void
+nsIWidget::UpdateRegisteredPluginWindowVisibility(uintptr_t aOwnerWidget,
+ nsTArray<uintptr_t>& aPluginIds)
+{
+#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
+ NS_NOTREACHED("nsBaseWidget::UpdateRegisteredPluginWindowVisibility not implemented!");
+ return;
+#else
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(sPluginWidgetList);
+
+ // Our visible list is associated with a compositor which is associated with
+ // a specific top level window. We use the parent widget during iteration
+ // to skip the plugin widgets owned by other top level windows.
+ for (auto iter = sPluginWidgetList->Iter(); !iter.Done(); iter.Next()) {
+ const void* windowId = iter.Key();
+ nsIWidget* widget = iter.UserData();
+
+ MOZ_ASSERT(windowId);
+ MOZ_ASSERT(widget);
+
+ if (!widget->Destroyed()) {
+ if ((uintptr_t)widget->GetParent() == aOwnerWidget) {
+ widget->Show(aPluginIds.Contains((uintptr_t)windowId));
+ }
+ }
+ }
+#endif
+}
+
+#if defined(XP_WIN)
+// static
+void
+nsIWidget::CaptureRegisteredPlugins(uintptr_t aOwnerWidget)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(sPluginWidgetList);
+
+ // Our visible list is associated with a compositor which is associated with
+ // a specific top level window. We use the parent widget during iteration
+ // to skip the plugin widgets owned by other top level windows.
+ for (auto iter = sPluginWidgetList->Iter(); !iter.Done(); iter.Next()) {
+ const void* windowId = iter.Key();
+ nsIWidget* widget = iter.UserData();
+
+ MOZ_ASSERT(windowId);
+ MOZ_ASSERT(widget);
+
+ if (!widget->Destroyed() && widget->IsVisible()) {
+ if ((uintptr_t)widget->GetParent() == aOwnerWidget) {
+ widget->UpdateScrollCapture();
+ }
+ }
+ }
+}
+
+uint64_t
+nsBaseWidget::CreateScrollCaptureContainer()
+{
+ mScrollCaptureContainer =
+ LayerManager::CreateImageContainer(ImageContainer::ASYNCHRONOUS);
+ if (!mScrollCaptureContainer) {
+ NS_WARNING("Failed to create ImageContainer for widget image capture.");
+ return ImageContainer::sInvalidAsyncContainerId;
+ }
+
+ return mScrollCaptureContainer->GetAsyncContainerID();
+}
+
+void
+nsBaseWidget::UpdateScrollCapture()
+{
+ // Don't capture if no container or no size.
+ if (!mScrollCaptureContainer || mBounds.width <= 0 || mBounds.height <= 0) {
+ return;
+ }
+
+ // If the derived class cannot take a snapshot, for example due to clipping,
+ // then it is responsible for creating a fallback. If null is returned, this
+ // means that we want to keep the existing snapshot.
+ RefPtr<gfx::SourceSurface> snapshot = CreateScrollSnapshot();
+ if (!snapshot) {
+ return;
+ }
+
+ ImageContainer::NonOwningImage holder(new SourceSurfaceImage(snapshot));
+
+ AutoTArray<ImageContainer::NonOwningImage, 1> imageList;
+ imageList.AppendElement(holder);
+
+ mScrollCaptureContainer->SetCurrentImages(imageList);
+}
+
+void
+nsBaseWidget::DefaultFillScrollCapture(DrawTarget* aSnapshotDrawTarget)
+{
+ gfx::IntSize dtSize = aSnapshotDrawTarget->GetSize();
+ aSnapshotDrawTarget->FillRect(
+ gfx::Rect(0, 0, dtSize.width, dtSize.height),
+ gfx::ColorPattern(gfx::Color::FromABGR(kScrollCaptureFillColor)),
+ gfx::DrawOptions(1.f, gfx::CompositionOp::OP_SOURCE));
+ aSnapshotDrawTarget->Flush();
+}
+#endif
+
+NS_IMETHODIMP_(nsIWidget::NativeIMEContext)
+nsIWidget::GetNativeIMEContext()
+{
+ return NativeIMEContext(this);
+}
+
+nsresult
+nsIWidget::OnWindowedPluginKeyEvent(const NativeEventData& aKeyEventData,
+ nsIKeyEventInPluginCallback* aCallback)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+namespace mozilla {
+namespace widget {
+
+const char*
+ToChar(IMEMessage aIMEMessage)
+{
+ switch (aIMEMessage) {
+ case NOTIFY_IME_OF_NOTHING:
+ return "NOTIFY_IME_OF_NOTHING";
+ case NOTIFY_IME_OF_FOCUS:
+ return "NOTIFY_IME_OF_FOCUS";
+ case NOTIFY_IME_OF_BLUR:
+ return "NOTIFY_IME_OF_BLUR";
+ case NOTIFY_IME_OF_SELECTION_CHANGE:
+ return "NOTIFY_IME_OF_SELECTION_CHANGE";
+ case NOTIFY_IME_OF_TEXT_CHANGE:
+ return "NOTIFY_IME_OF_TEXT_CHANGE";
+ case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED:
+ return "NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED";
+ case NOTIFY_IME_OF_POSITION_CHANGE:
+ return "NOTIFY_IME_OF_POSITION_CHANGE";
+ case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
+ return "NOTIFY_IME_OF_MOUSE_BUTTON_EVENT";
+ case REQUEST_TO_COMMIT_COMPOSITION:
+ return "REQUEST_TO_COMMIT_COMPOSITION";
+ case REQUEST_TO_CANCEL_COMPOSITION:
+ return "REQUEST_TO_CANCEL_COMPOSITION";
+ default:
+ return "Unexpected value";
+ }
+}
+
+void
+NativeIMEContext::Init(nsIWidget* aWidget)
+{
+ if (!aWidget) {
+ mRawNativeIMEContext = reinterpret_cast<uintptr_t>(nullptr);
+ mOriginProcessID = static_cast<uint64_t>(-1);
+ return;
+ }
+ if (!XRE_IsContentProcess()) {
+ mRawNativeIMEContext = reinterpret_cast<uintptr_t>(
+ aWidget->GetNativeData(NS_RAW_NATIVE_IME_CONTEXT));
+ mOriginProcessID = 0;
+ return;
+ }
+ // If this is created in a child process, aWidget is an instance of
+ // PuppetWidget which doesn't support NS_RAW_NATIVE_IME_CONTEXT.
+ // Instead of that PuppetWidget::GetNativeIMEContext() returns cached
+ // native IME context of the parent process.
+ *this = aWidget->GetNativeIMEContext();
+}
+
+void
+NativeIMEContext::InitWithRawNativeIMEContext(void* aRawNativeIMEContext)
+{
+ if (NS_WARN_IF(!aRawNativeIMEContext)) {
+ mRawNativeIMEContext = reinterpret_cast<uintptr_t>(nullptr);
+ mOriginProcessID = static_cast<uint64_t>(-1);
+ return;
+ }
+ mRawNativeIMEContext = reinterpret_cast<uintptr_t>(aRawNativeIMEContext);
+ mOriginProcessID =
+ XRE_IsContentProcess() ? ContentChild::GetSingleton()->GetID() : 0;
+}
+
+void
+IMENotification::TextChangeDataBase::MergeWith(
+ const IMENotification::TextChangeDataBase& aOther)
+{
+ MOZ_ASSERT(aOther.IsValid(),
+ "Merging data must store valid data");
+ MOZ_ASSERT(aOther.mStartOffset <= aOther.mRemovedEndOffset,
+ "end of removed text must be same or larger than start");
+ MOZ_ASSERT(aOther.mStartOffset <= aOther.mAddedEndOffset,
+ "end of added text must be same or larger than start");
+
+ if (!IsValid()) {
+ *this = aOther;
+ return;
+ }
+
+ // |mStartOffset| and |mRemovedEndOffset| represent all replaced or removed
+ // text ranges. I.e., mStartOffset should be the smallest offset of all
+ // modified text ranges in old text. |mRemovedEndOffset| should be the
+ // largest end offset in old text of all modified text ranges.
+ // |mAddedEndOffset| represents the end offset of all inserted text ranges.
+ // I.e., only this is an offset in new text.
+ // In other words, between mStartOffset and |mRemovedEndOffset| of the
+ // premodified text was already removed. And some text whose length is
+ // |mAddedEndOffset - mStartOffset| is inserted to |mStartOffset|. I.e.,
+ // this allows IME to mark dirty the modified text range with |mStartOffset|
+ // and |mRemovedEndOffset| if IME stores all text of the focused editor and
+ // to compute new text length with |mAddedEndOffset| and |mRemovedEndOffset|.
+ // Additionally, IME can retrieve only the text between |mStartOffset| and
+ // |mAddedEndOffset| for updating stored text.
+
+ // For comparing new and old |mStartOffset|/|mRemovedEndOffset| values, they
+ // should be adjusted to be in same text. The |newData.mStartOffset| and
+ // |newData.mRemovedEndOffset| should be computed as in old text because
+ // |mStartOffset| and |mRemovedEndOffset| represent the modified text range
+ // in the old text but even if some text before the values of the newData
+ // has already been modified, the values don't include the changes.
+
+ // For comparing new and old |mAddedEndOffset| values, they should be
+ // adjusted to be in same text. The |oldData.mAddedEndOffset| should be
+ // computed as in the new text because |mAddedEndOffset| indicates the end
+ // offset of inserted text in the new text but |oldData.mAddedEndOffset|
+ // doesn't include any changes of the text before |newData.mAddedEndOffset|.
+
+ const TextChangeDataBase& newData = aOther;
+ const TextChangeDataBase oldData = *this;
+
+ // mCausedOnlyByComposition should be true only when all changes are caused
+ // by composition.
+ mCausedOnlyByComposition =
+ newData.mCausedOnlyByComposition && oldData.mCausedOnlyByComposition;
+
+ // mIncludingChangesWithoutComposition should be true if at least one of
+ // merged changes occurred without composition.
+ mIncludingChangesWithoutComposition =
+ newData.mIncludingChangesWithoutComposition ||
+ oldData.mIncludingChangesWithoutComposition;
+
+ // mIncludingChangesDuringComposition should be true when at least one of
+ // the merged non-composition changes occurred during the latest composition.
+ if (!newData.mCausedOnlyByComposition &&
+ !newData.mIncludingChangesDuringComposition) {
+ MOZ_ASSERT(newData.mIncludingChangesWithoutComposition);
+ MOZ_ASSERT(mIncludingChangesWithoutComposition);
+ // If new change is neither caused by composition nor occurred during
+ // composition, set mIncludingChangesDuringComposition to false because
+ // IME doesn't want outdated text changes as text change during current
+ // composition.
+ mIncludingChangesDuringComposition = false;
+ } else {
+ // Otherwise, set mIncludingChangesDuringComposition to true if either
+ // oldData or newData includes changes during composition.
+ mIncludingChangesDuringComposition =
+ newData.mIncludingChangesDuringComposition ||
+ oldData.mIncludingChangesDuringComposition;
+ }
+
+ if (newData.mStartOffset >= oldData.mAddedEndOffset) {
+ // Case 1:
+ // If new start is after old end offset of added text, it means that text
+ // after the modified range is modified. Like:
+ // added range of old change: +----------+
+ // removed range of new change: +----------+
+ // So, the old start offset is always the smaller offset.
+ mStartOffset = oldData.mStartOffset;
+ // The new end offset of removed text is moved by the old change and we
+ // need to cancel the move of the old change for comparing the offsets in
+ // same text because it doesn't make sensce to compare offsets in different
+ // text.
+ uint32_t newRemovedEndOffsetInOldText =
+ newData.mRemovedEndOffset - oldData.Difference();
+ mRemovedEndOffset =
+ std::max(newRemovedEndOffsetInOldText, oldData.mRemovedEndOffset);
+ // The new end offset of added text is always the larger offset.
+ mAddedEndOffset = newData.mAddedEndOffset;
+ return;
+ }
+
+ if (newData.mStartOffset >= oldData.mStartOffset) {
+ // If new start is in the modified range, it means that new data changes
+ // a part or all of the range.
+ mStartOffset = oldData.mStartOffset;
+ if (newData.mRemovedEndOffset >= oldData.mAddedEndOffset) {
+ // Case 2:
+ // If new end of removed text is greater than old end of added text, it
+ // means that all or a part of modified range modified again and text
+ // after the modified range is also modified. Like:
+ // added range of old change: +----------+
+ // removed range of new change: +----------+
+ // So, the new removed end offset is moved by the old change and we need
+ // to cancel the move of the old change for comparing the offsets in the
+ // same text because it doesn't make sense to compare the offsets in
+ // different text.
+ uint32_t newRemovedEndOffsetInOldText =
+ newData.mRemovedEndOffset - oldData.Difference();
+ mRemovedEndOffset =
+ std::max(newRemovedEndOffsetInOldText, oldData.mRemovedEndOffset);
+ // The old end of added text is replaced by new change. So, it should be
+ // same as the new start. On the other hand, the new added end offset is
+ // always same or larger. Therefore, the merged end offset of added
+ // text should be the new end offset of added text.
+ mAddedEndOffset = newData.mAddedEndOffset;
+ return;
+ }
+
+ // Case 3:
+ // If new end of removed text is less than old end of added text, it means
+ // that only a part of the modified range is modified again. Like:
+ // added range of old change: +------------+
+ // removed range of new change: +-----+
+ // So, the new end offset of removed text should be same as the old end
+ // offset of removed text. Therefore, the merged end offset of removed
+ // text should be the old text change's |mRemovedEndOffset|.
+ mRemovedEndOffset = oldData.mRemovedEndOffset;
+ // The old end of added text is moved by new change. So, we need to cancel
+ // the move of the new change for comparing the offsets in same text.
+ uint32_t oldAddedEndOffsetInNewText =
+ oldData.mAddedEndOffset + newData.Difference();
+ mAddedEndOffset =
+ std::max(newData.mAddedEndOffset, oldAddedEndOffsetInNewText);
+ return;
+ }
+
+ if (newData.mRemovedEndOffset >= oldData.mStartOffset) {
+ // If new end of removed text is greater than old start (and new start is
+ // less than old start), it means that a part of modified range is modified
+ // again and some new text before the modified range is also modified.
+ MOZ_ASSERT(newData.mStartOffset < oldData.mStartOffset,
+ "new start offset should be less than old one here");
+ mStartOffset = newData.mStartOffset;
+ if (newData.mRemovedEndOffset >= oldData.mAddedEndOffset) {
+ // Case 4:
+ // If new end of removed text is greater than old end of added text, it
+ // means that all modified text and text after the modified range is
+ // modified. Like:
+ // added range of old change: +----------+
+ // removed range of new change: +------------------+
+ // So, the new end of removed text is moved by the old change. Therefore,
+ // we need to cancel the move of the old change for comparing the offsets
+ // in same text because it doesn't make sense to compare the offsets in
+ // different text.
+ uint32_t newRemovedEndOffsetInOldText =
+ newData.mRemovedEndOffset - oldData.Difference();
+ mRemovedEndOffset =
+ std::max(newRemovedEndOffsetInOldText, oldData.mRemovedEndOffset);
+ // The old end of added text is replaced by new change. So, the old end
+ // offset of added text is same as new text change's start offset. Then,
+ // new change's end offset of added text is always same or larger than
+ // it. Therefore, merged end offset of added text is always the new end
+ // offset of added text.
+ mAddedEndOffset = newData.mAddedEndOffset;
+ return;
+ }
+
+ // Case 5:
+ // If new end of removed text is less than old end of added text, it
+ // means that only a part of the modified range is modified again. Like:
+ // added range of old change: +----------+
+ // removed range of new change: +----------+
+ // So, the new end of removed text should be same as old end of removed
+ // text for preventing end of removed text to be modified. Therefore,
+ // merged end offset of removed text is always the old end offset of removed
+ // text.
+ mRemovedEndOffset = oldData.mRemovedEndOffset;
+ // The old end of added text is moved by this change. So, we need to
+ // cancel the move of the new change for comparing the offsets in same text
+ // because it doesn't make sense to compare the offsets in different text.
+ uint32_t oldAddedEndOffsetInNewText =
+ oldData.mAddedEndOffset + newData.Difference();
+ mAddedEndOffset =
+ std::max(newData.mAddedEndOffset, oldAddedEndOffsetInNewText);
+ return;
+ }
+
+ // Case 6:
+ // Otherwise, i.e., both new end of added text and new start are less than
+ // old start, text before the modified range is modified. Like:
+ // added range of old change: +----------+
+ // removed range of new change: +----------+
+ MOZ_ASSERT(newData.mStartOffset < oldData.mStartOffset,
+ "new start offset should be less than old one here");
+ mStartOffset = newData.mStartOffset;
+ MOZ_ASSERT(newData.mRemovedEndOffset < oldData.mRemovedEndOffset,
+ "new removed end offset should be less than old one here");
+ mRemovedEndOffset = oldData.mRemovedEndOffset;
+ // The end of added text should be adjusted with the new difference.
+ uint32_t oldAddedEndOffsetInNewText =
+ oldData.mAddedEndOffset + newData.Difference();
+ mAddedEndOffset =
+ std::max(newData.mAddedEndOffset, oldAddedEndOffsetInNewText);
+}
+
+#ifdef DEBUG
+
+// Let's test the code of merging multiple text change data in debug build
+// and crash if one of them fails because this feature is very complex but
+// cannot be tested with mochitest.
+void
+IMENotification::TextChangeDataBase::Test()
+{
+ static bool gTestTextChangeEvent = true;
+ if (!gTestTextChangeEvent) {
+ return;
+ }
+ gTestTextChangeEvent = false;
+
+ /****************************************************************************
+ * Case 1
+ ****************************************************************************/
+
+ // Appending text
+ MergeWith(TextChangeData(10, 10, 20, false, false));
+ MergeWith(TextChangeData(20, 20, 35, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 1-1-1: mStartOffset should be the first offset");
+ MOZ_ASSERT(mRemovedEndOffset == 10, // 20 - (20 - 10)
+ "Test 1-1-2: mRemovedEndOffset should be the first end of removed text");
+ MOZ_ASSERT(mAddedEndOffset == 35,
+ "Test 1-1-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Removing text (longer line -> shorter line)
+ MergeWith(TextChangeData(10, 20, 10, false, false));
+ MergeWith(TextChangeData(10, 30, 10, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 1-2-1: mStartOffset should be the first offset");
+ MOZ_ASSERT(mRemovedEndOffset == 40, // 30 + (10 - 20)
+ "Test 1-2-2: mRemovedEndOffset should be the the last end of removed text "
+ "with already removed length");
+ MOZ_ASSERT(mAddedEndOffset == 10,
+ "Test 1-2-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Removing text (shorter line -> longer line)
+ MergeWith(TextChangeData(10, 20, 10, false, false));
+ MergeWith(TextChangeData(10, 15, 10, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 1-3-1: mStartOffset should be the first offset");
+ MOZ_ASSERT(mRemovedEndOffset == 25, // 15 + (10 - 20)
+ "Test 1-3-2: mRemovedEndOffset should be the the last end of removed text "
+ "with already removed length");
+ MOZ_ASSERT(mAddedEndOffset == 10,
+ "Test 1-3-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Appending text at different point (not sure if actually occurs)
+ MergeWith(TextChangeData(10, 10, 20, false, false));
+ MergeWith(TextChangeData(55, 55, 60, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 1-4-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 45, // 55 - (10 - 20)
+ "Test 1-4-2: mRemovedEndOffset should be the the largest end of removed "
+ "text without already added length");
+ MOZ_ASSERT(mAddedEndOffset == 60,
+ "Test 1-4-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Removing text at different point (not sure if actually occurs)
+ MergeWith(TextChangeData(10, 20, 10, false, false));
+ MergeWith(TextChangeData(55, 68, 55, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 1-5-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 78, // 68 - (10 - 20)
+ "Test 1-5-2: mRemovedEndOffset should be the the largest end of removed "
+ "text with already removed length");
+ MOZ_ASSERT(mAddedEndOffset == 55,
+ "Test 1-5-3: mAddedEndOffset should be the largest end of added text");
+ Clear();
+
+ // Replacing text and append text (becomes longer)
+ MergeWith(TextChangeData(30, 35, 32, false, false));
+ MergeWith(TextChangeData(32, 32, 40, false, false));
+ MOZ_ASSERT(mStartOffset == 30,
+ "Test 1-6-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 35, // 32 - (32 - 35)
+ "Test 1-6-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 40,
+ "Test 1-6-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Replacing text and append text (becomes shorter)
+ MergeWith(TextChangeData(30, 35, 32, false, false));
+ MergeWith(TextChangeData(32, 32, 33, false, false));
+ MOZ_ASSERT(mStartOffset == 30,
+ "Test 1-7-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 35, // 32 - (32 - 35)
+ "Test 1-7-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 33,
+ "Test 1-7-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Removing text and replacing text after first range (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(30, 35, 30, false, false));
+ MergeWith(TextChangeData(32, 34, 48, false, false));
+ MOZ_ASSERT(mStartOffset == 30,
+ "Test 1-8-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 39, // 34 - (30 - 35)
+ "Test 1-8-2: mRemovedEndOffset should be the the first end of removed text "
+ "without already removed text");
+ MOZ_ASSERT(mAddedEndOffset == 48,
+ "Test 1-8-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Removing text and replacing text after first range (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(30, 35, 30, false, false));
+ MergeWith(TextChangeData(32, 38, 36, false, false));
+ MOZ_ASSERT(mStartOffset == 30,
+ "Test 1-9-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 43, // 38 - (30 - 35)
+ "Test 1-9-2: mRemovedEndOffset should be the the first end of removed text "
+ "without already removed text");
+ MOZ_ASSERT(mAddedEndOffset == 36,
+ "Test 1-9-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ /****************************************************************************
+ * Case 2
+ ****************************************************************************/
+
+ // Replacing text in around end of added text (becomes shorter) (not sure
+ // if actually occurs)
+ MergeWith(TextChangeData(50, 50, 55, false, false));
+ MergeWith(TextChangeData(53, 60, 54, false, false));
+ MOZ_ASSERT(mStartOffset == 50,
+ "Test 2-1-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 55, // 60 - (55 - 50)
+ "Test 2-1-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already added text length");
+ MOZ_ASSERT(mAddedEndOffset == 54,
+ "Test 2-1-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Replacing text around end of added text (becomes longer) (not sure
+ // if actually occurs)
+ MergeWith(TextChangeData(50, 50, 55, false, false));
+ MergeWith(TextChangeData(54, 62, 68, false, false));
+ MOZ_ASSERT(mStartOffset == 50,
+ "Test 2-2-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 57, // 62 - (55 - 50)
+ "Test 2-2-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already added text length");
+ MOZ_ASSERT(mAddedEndOffset == 68,
+ "Test 2-2-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Replacing text around end of replaced text (became shorter) (not sure if
+ // actually occurs)
+ MergeWith(TextChangeData(36, 48, 45, false, false));
+ MergeWith(TextChangeData(43, 50, 49, false, false));
+ MOZ_ASSERT(mStartOffset == 36,
+ "Test 2-3-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 53, // 50 - (45 - 48)
+ "Test 2-3-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already removed text length");
+ MOZ_ASSERT(mAddedEndOffset == 49,
+ "Test 2-3-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Replacing text around end of replaced text (became longer) (not sure if
+ // actually occurs)
+ MergeWith(TextChangeData(36, 52, 53, false, false));
+ MergeWith(TextChangeData(43, 68, 61, false, false));
+ MOZ_ASSERT(mStartOffset == 36,
+ "Test 2-4-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 67, // 68 - (53 - 52)
+ "Test 2-4-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already added text length");
+ MOZ_ASSERT(mAddedEndOffset == 61,
+ "Test 2-4-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ /****************************************************************************
+ * Case 3
+ ****************************************************************************/
+
+ // Appending text in already added text (not sure if actually occurs)
+ MergeWith(TextChangeData(10, 10, 20, false, false));
+ MergeWith(TextChangeData(15, 15, 30, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 3-1-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 10,
+ "Test 3-1-2: mRemovedEndOffset should be the the first end of removed text");
+ MOZ_ASSERT(mAddedEndOffset == 35, // 20 + (30 - 15)
+ "Test 3-1-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ // Replacing text in added text (not sure if actually occurs)
+ MergeWith(TextChangeData(50, 50, 55, false, false));
+ MergeWith(TextChangeData(52, 53, 56, false, false));
+ MOZ_ASSERT(mStartOffset == 50,
+ "Test 3-2-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 50,
+ "Test 3-2-2: mRemovedEndOffset should be the the first end of removed text");
+ MOZ_ASSERT(mAddedEndOffset == 58, // 55 + (56 - 53)
+ "Test 3-2-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ // Replacing text in replaced text (became shorter) (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(36, 48, 45, false, false));
+ MergeWith(TextChangeData(37, 38, 50, false, false));
+ MOZ_ASSERT(mStartOffset == 36,
+ "Test 3-3-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 48,
+ "Test 3-3-2: mRemovedEndOffset should be the the first end of removed text");
+ MOZ_ASSERT(mAddedEndOffset == 57, // 45 + (50 - 38)
+ "Test 3-3-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ // Replacing text in replaced text (became longer) (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(32, 48, 53, false, false));
+ MergeWith(TextChangeData(43, 50, 52, false, false));
+ MOZ_ASSERT(mStartOffset == 32,
+ "Test 3-4-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 48,
+ "Test 3-4-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already added text length");
+ MOZ_ASSERT(mAddedEndOffset == 55, // 53 + (52 - 50)
+ "Test 3-4-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ // Replacing text in replaced text (became shorter) (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(36, 48, 50, false, false));
+ MergeWith(TextChangeData(37, 49, 47, false, false));
+ MOZ_ASSERT(mStartOffset == 36,
+ "Test 3-5-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 48,
+ "Test 3-5-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 48, // 50 + (47 - 49)
+ "Test 3-5-3: mAddedEndOffset should be the first end of added text without "
+ "removed text length by the new change");
+ Clear();
+
+ // Replacing text in replaced text (became longer) (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(32, 48, 53, false, false));
+ MergeWith(TextChangeData(43, 50, 47, false, false));
+ MOZ_ASSERT(mStartOffset == 32,
+ "Test 3-6-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 48,
+ "Test 3-6-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already added text length");
+ MOZ_ASSERT(mAddedEndOffset == 50, // 53 + (47 - 50)
+ "Test 3-6-3: mAddedEndOffset should be the first end of added text without "
+ "removed text length by the new change");
+ Clear();
+
+ /****************************************************************************
+ * Case 4
+ ****************************************************************************/
+
+ // Replacing text all of already append text (not sure if actually occurs)
+ MergeWith(TextChangeData(50, 50, 55, false, false));
+ MergeWith(TextChangeData(44, 66, 68, false, false));
+ MOZ_ASSERT(mStartOffset == 44,
+ "Test 4-1-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 61, // 66 - (55 - 50)
+ "Test 4-1-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already added text length");
+ MOZ_ASSERT(mAddedEndOffset == 68,
+ "Test 4-1-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Replacing text around a point in which text was removed (not sure if
+ // actually occurs)
+ MergeWith(TextChangeData(50, 62, 50, false, false));
+ MergeWith(TextChangeData(44, 66, 68, false, false));
+ MOZ_ASSERT(mStartOffset == 44,
+ "Test 4-2-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 78, // 66 - (50 - 62)
+ "Test 4-2-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already removed text length");
+ MOZ_ASSERT(mAddedEndOffset == 68,
+ "Test 4-2-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Replacing text all replaced text (became shorter) (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(50, 62, 60, false, false));
+ MergeWith(TextChangeData(49, 128, 130, false, false));
+ MOZ_ASSERT(mStartOffset == 49,
+ "Test 4-3-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 130, // 128 - (60 - 62)
+ "Test 4-3-2: mRemovedEndOffset should be the the last end of removed text "
+ "without already removed text length");
+ MOZ_ASSERT(mAddedEndOffset == 130,
+ "Test 4-3-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ // Replacing text all replaced text (became longer) (not sure if actually
+ // occurs)
+ MergeWith(TextChangeData(50, 61, 73, false, false));
+ MergeWith(TextChangeData(44, 100, 50, false, false));
+ MOZ_ASSERT(mStartOffset == 44,
+ "Test 4-4-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 88, // 100 - (73 - 61)
+ "Test 4-4-2: mRemovedEndOffset should be the the last end of removed text "
+ "with already added text length");
+ MOZ_ASSERT(mAddedEndOffset == 50,
+ "Test 4-4-3: mAddedEndOffset should be the last end of added text");
+ Clear();
+
+ /****************************************************************************
+ * Case 5
+ ****************************************************************************/
+
+ // Replacing text around start of added text (not sure if actually occurs)
+ MergeWith(TextChangeData(50, 50, 55, false, false));
+ MergeWith(TextChangeData(48, 52, 49, false, false));
+ MOZ_ASSERT(mStartOffset == 48,
+ "Test 5-1-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 50,
+ "Test 5-1-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 52, // 55 + (52 - 49)
+ "Test 5-1-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ // Replacing text around start of replaced text (became shorter) (not sure if
+ // actually occurs)
+ MergeWith(TextChangeData(50, 60, 58, false, false));
+ MergeWith(TextChangeData(43, 50, 48, false, false));
+ MOZ_ASSERT(mStartOffset == 43,
+ "Test 5-2-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 60,
+ "Test 5-2-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 56, // 58 + (48 - 50)
+ "Test 5-2-3: mAddedEndOffset should be the first end of added text without "
+ "removed text length by the new change");
+ Clear();
+
+ // Replacing text around start of replaced text (became longer) (not sure if
+ // actually occurs)
+ MergeWith(TextChangeData(50, 60, 68, false, false));
+ MergeWith(TextChangeData(43, 55, 53, false, false));
+ MOZ_ASSERT(mStartOffset == 43,
+ "Test 5-3-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 60,
+ "Test 5-3-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 66, // 68 + (53 - 55)
+ "Test 5-3-3: mAddedEndOffset should be the first end of added text without "
+ "removed text length by the new change");
+ Clear();
+
+ // Replacing text around start of replaced text (became shorter) (not sure if
+ // actually occurs)
+ MergeWith(TextChangeData(50, 60, 58, false, false));
+ MergeWith(TextChangeData(43, 50, 128, false, false));
+ MOZ_ASSERT(mStartOffset == 43,
+ "Test 5-4-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 60,
+ "Test 5-4-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 136, // 58 + (128 - 50)
+ "Test 5-4-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ // Replacing text around start of replaced text (became longer) (not sure if
+ // actually occurs)
+ MergeWith(TextChangeData(50, 60, 68, false, false));
+ MergeWith(TextChangeData(43, 55, 65, false, false));
+ MOZ_ASSERT(mStartOffset == 43,
+ "Test 5-5-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 60,
+ "Test 5-5-2: mRemovedEndOffset should be the the first end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 78, // 68 + (65 - 55)
+ "Test 5-5-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ /****************************************************************************
+ * Case 6
+ ****************************************************************************/
+
+ // Appending text before already added text (not sure if actually occurs)
+ MergeWith(TextChangeData(30, 30, 45, false, false));
+ MergeWith(TextChangeData(10, 10, 20, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 6-1-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 30,
+ "Test 6-1-2: mRemovedEndOffset should be the the largest end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 55, // 45 + (20 - 10)
+ "Test 6-1-3: mAddedEndOffset should be the first end of added text with "
+ "added text length by the new change");
+ Clear();
+
+ // Removing text before already removed text (not sure if actually occurs)
+ MergeWith(TextChangeData(30, 35, 30, false, false));
+ MergeWith(TextChangeData(10, 25, 10, false, false));
+ MOZ_ASSERT(mStartOffset == 10,
+ "Test 6-2-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 35,
+ "Test 6-2-2: mRemovedEndOffset should be the the largest end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 15, // 30 - (25 - 10)
+ "Test 6-2-3: mAddedEndOffset should be the first end of added text with "
+ "removed text length by the new change");
+ Clear();
+
+ // Replacing text before already replaced text (not sure if actually occurs)
+ MergeWith(TextChangeData(50, 65, 70, false, false));
+ MergeWith(TextChangeData(13, 24, 15, false, false));
+ MOZ_ASSERT(mStartOffset == 13,
+ "Test 6-3-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 65,
+ "Test 6-3-2: mRemovedEndOffset should be the the largest end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 61, // 70 + (15 - 24)
+ "Test 6-3-3: mAddedEndOffset should be the first end of added text without "
+ "removed text length by the new change");
+ Clear();
+
+ // Replacing text before already replaced text (not sure if actually occurs)
+ MergeWith(TextChangeData(50, 65, 70, false, false));
+ MergeWith(TextChangeData(13, 24, 36, false, false));
+ MOZ_ASSERT(mStartOffset == 13,
+ "Test 6-4-1: mStartOffset should be the smallest offset");
+ MOZ_ASSERT(mRemovedEndOffset == 65,
+ "Test 6-4-2: mRemovedEndOffset should be the the largest end of removed "
+ "text");
+ MOZ_ASSERT(mAddedEndOffset == 82, // 70 + (36 - 24)
+ "Test 6-4-3: mAddedEndOffset should be the first end of added text without "
+ "removed text length by the new change");
+ Clear();
+}
+
+#endif // #ifdef DEBUG
+
+} // namespace widget
+} // namespace mozilla
+
+#ifdef DEBUG
+//////////////////////////////////////////////////////////////
+//
+// Convert a GUI event message code to a string.
+// Makes it a lot easier to debug events.
+//
+// See gtk/nsWidget.cpp and windows/nsWindow.cpp
+// for a DebugPrintEvent() function that uses
+// this.
+//
+//////////////////////////////////////////////////////////////
+/* static */ nsAutoString
+nsBaseWidget::debug_GuiEventToString(WidgetGUIEvent* aGuiEvent)
+{
+ NS_ASSERTION(nullptr != aGuiEvent,"cmon, null gui event.");
+
+ nsAutoString eventName(NS_LITERAL_STRING("UNKNOWN"));
+
+#define _ASSIGN_eventName(_value,_name)\
+case _value: eventName.AssignLiteral(_name) ; break
+
+ switch(aGuiEvent->mMessage)
+ {
+ _ASSIGN_eventName(eBlur,"eBlur");
+ _ASSIGN_eventName(eDrop,"eDrop");
+ _ASSIGN_eventName(eDragEnter,"eDragEnter");
+ _ASSIGN_eventName(eDragExit,"eDragExit");
+ _ASSIGN_eventName(eDragOver,"eDragOver");
+ _ASSIGN_eventName(eEditorInput,"eEditorInput");
+ _ASSIGN_eventName(eFocus,"eFocus");
+ _ASSIGN_eventName(eFocusIn,"eFocusIn");
+ _ASSIGN_eventName(eFocusOut,"eFocusOut");
+ _ASSIGN_eventName(eFormSelect,"eFormSelect");
+ _ASSIGN_eventName(eFormChange,"eFormChange");
+ _ASSIGN_eventName(eFormReset,"eFormReset");
+ _ASSIGN_eventName(eFormSubmit,"eFormSubmit");
+ _ASSIGN_eventName(eImageAbort,"eImageAbort");
+ _ASSIGN_eventName(eLoadError,"eLoadError");
+ _ASSIGN_eventName(eKeyDown,"eKeyDown");
+ _ASSIGN_eventName(eKeyPress,"eKeyPress");
+ _ASSIGN_eventName(eKeyUp,"eKeyUp");
+ _ASSIGN_eventName(eMouseEnterIntoWidget,"eMouseEnterIntoWidget");
+ _ASSIGN_eventName(eMouseExitFromWidget,"eMouseExitFromWidget");
+ _ASSIGN_eventName(eMouseDown,"eMouseDown");
+ _ASSIGN_eventName(eMouseUp,"eMouseUp");
+ _ASSIGN_eventName(eMouseClick,"eMouseClick");
+ _ASSIGN_eventName(eMouseDoubleClick,"eMouseDoubleClick");
+ _ASSIGN_eventName(eMouseMove,"eMouseMove");
+ _ASSIGN_eventName(eLoad,"eLoad");
+ _ASSIGN_eventName(ePopState,"ePopState");
+ _ASSIGN_eventName(eBeforeScriptExecute,"eBeforeScriptExecute");
+ _ASSIGN_eventName(eAfterScriptExecute,"eAfterScriptExecute");
+ _ASSIGN_eventName(eUnload,"eUnload");
+ _ASSIGN_eventName(eHashChange,"eHashChange");
+ _ASSIGN_eventName(eReadyStateChange,"eReadyStateChange");
+ _ASSIGN_eventName(eXULBroadcast, "eXULBroadcast");
+ _ASSIGN_eventName(eXULCommandUpdate, "eXULCommandUpdate");
+
+#undef _ASSIGN_eventName
+
+ default:
+ {
+ char buf[32];
+
+ SprintfLiteral(buf,"UNKNOWN: %d",aGuiEvent->mMessage);
+
+ CopyASCIItoUTF16(buf, eventName);
+ }
+ break;
+ }
+
+ return nsAutoString(eventName);
+}
+//////////////////////////////////////////////////////////////
+//
+// Code to deal with paint and event debug prefs.
+//
+//////////////////////////////////////////////////////////////
+struct PrefPair
+{
+ const char * name;
+ bool value;
+};
+
+static PrefPair debug_PrefValues[] =
+{
+ { "nglayout.debug.crossing_event_dumping", false },
+ { "nglayout.debug.event_dumping", false },
+ { "nglayout.debug.invalidate_dumping", false },
+ { "nglayout.debug.motion_event_dumping", false },
+ { "nglayout.debug.paint_dumping", false },
+ { "nglayout.debug.paint_flashing", false }
+};
+
+//////////////////////////////////////////////////////////////
+bool
+nsBaseWidget::debug_GetCachedBoolPref(const char * aPrefName)
+{
+ NS_ASSERTION(nullptr != aPrefName,"cmon, pref name is null.");
+
+ for (uint32_t i = 0; i < ArrayLength(debug_PrefValues); i++)
+ {
+ if (strcmp(debug_PrefValues[i].name, aPrefName) == 0)
+ {
+ return debug_PrefValues[i].value;
+ }
+ }
+
+ return false;
+}
+//////////////////////////////////////////////////////////////
+static void debug_SetCachedBoolPref(const char * aPrefName,bool aValue)
+{
+ NS_ASSERTION(nullptr != aPrefName,"cmon, pref name is null.");
+
+ for (uint32_t i = 0; i < ArrayLength(debug_PrefValues); i++)
+ {
+ if (strcmp(debug_PrefValues[i].name, aPrefName) == 0)
+ {
+ debug_PrefValues[i].value = aValue;
+
+ return;
+ }
+ }
+
+ NS_ASSERTION(false, "cmon, this code is not reached dude.");
+}
+
+//////////////////////////////////////////////////////////////
+class Debug_PrefObserver final : public nsIObserver {
+ ~Debug_PrefObserver() {}
+
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+};
+
+NS_IMPL_ISUPPORTS(Debug_PrefObserver, nsIObserver)
+
+NS_IMETHODIMP
+Debug_PrefObserver::Observe(nsISupports* subject, const char* topic,
+ const char16_t* data)
+{
+ NS_ConvertUTF16toUTF8 prefName(data);
+
+ bool value = Preferences::GetBool(prefName.get(), false);
+ debug_SetCachedBoolPref(prefName.get(), value);
+ return NS_OK;
+}
+
+//////////////////////////////////////////////////////////////
+/* static */ void
+debug_RegisterPrefCallbacks()
+{
+ static bool once = true;
+
+ if (!once) {
+ return;
+ }
+
+ once = false;
+
+ nsCOMPtr<nsIObserver> obs(new Debug_PrefObserver());
+ for (uint32_t i = 0; i < ArrayLength(debug_PrefValues); i++) {
+ // Initialize the pref values
+ debug_PrefValues[i].value =
+ Preferences::GetBool(debug_PrefValues[i].name, false);
+
+ if (obs) {
+ // Register callbacks for when these change
+ Preferences::AddStrongObserver(obs, debug_PrefValues[i].name);
+ }
+ }
+}
+//////////////////////////////////////////////////////////////
+static int32_t
+_GetPrintCount()
+{
+ static int32_t sCount = 0;
+
+ return ++sCount;
+}
+//////////////////////////////////////////////////////////////
+/* static */ bool
+nsBaseWidget::debug_WantPaintFlashing()
+{
+ return debug_GetCachedBoolPref("nglayout.debug.paint_flashing");
+}
+//////////////////////////////////////////////////////////////
+/* static */ void
+nsBaseWidget::debug_DumpEvent(FILE * aFileOut,
+ nsIWidget * aWidget,
+ WidgetGUIEvent* aGuiEvent,
+ const char* aWidgetName,
+ int32_t aWindowID)
+{
+ if (aGuiEvent->mMessage == eMouseMove) {
+ if (!debug_GetCachedBoolPref("nglayout.debug.motion_event_dumping"))
+ return;
+ }
+
+ if (aGuiEvent->mMessage == eMouseEnterIntoWidget ||
+ aGuiEvent->mMessage == eMouseExitFromWidget) {
+ if (!debug_GetCachedBoolPref("nglayout.debug.crossing_event_dumping"))
+ return;
+ }
+
+ if (!debug_GetCachedBoolPref("nglayout.debug.event_dumping"))
+ return;
+
+ NS_LossyConvertUTF16toASCII tempString(debug_GuiEventToString(aGuiEvent).get());
+
+ fprintf(aFileOut,
+ "%4d %-26s widget=%-8p name=%-12s id=0x%-6x refpt=%d,%d\n",
+ _GetPrintCount(),
+ tempString.get(),
+ (void *) aWidget,
+ aWidgetName,
+ aWindowID,
+ aGuiEvent->mRefPoint.x,
+ aGuiEvent->mRefPoint.y);
+}
+//////////////////////////////////////////////////////////////
+/* static */ void
+nsBaseWidget::debug_DumpPaintEvent(FILE * aFileOut,
+ nsIWidget * aWidget,
+ const nsIntRegion & aRegion,
+ const char * aWidgetName,
+ int32_t aWindowID)
+{
+ NS_ASSERTION(nullptr != aFileOut,"cmon, null output FILE");
+ NS_ASSERTION(nullptr != aWidget,"cmon, the widget is null");
+
+ if (!debug_GetCachedBoolPref("nglayout.debug.paint_dumping"))
+ return;
+
+ nsIntRect rect = aRegion.GetBounds();
+ fprintf(aFileOut,
+ "%4d PAINT widget=%p name=%-12s id=0x%-6x bounds-rect=%3d,%-3d %3d,%-3d",
+ _GetPrintCount(),
+ (void *) aWidget,
+ aWidgetName,
+ aWindowID,
+ rect.x, rect.y, rect.width, rect.height
+ );
+
+ fprintf(aFileOut,"\n");
+}
+//////////////////////////////////////////////////////////////
+/* static */ void
+nsBaseWidget::debug_DumpInvalidate(FILE* aFileOut,
+ nsIWidget* aWidget,
+ const LayoutDeviceIntRect* aRect,
+ const char* aWidgetName,
+ int32_t aWindowID)
+{
+ if (!debug_GetCachedBoolPref("nglayout.debug.invalidate_dumping"))
+ return;
+
+ NS_ASSERTION(nullptr != aFileOut,"cmon, null output FILE");
+ NS_ASSERTION(nullptr != aWidget,"cmon, the widget is null");
+
+ fprintf(aFileOut,
+ "%4d Invalidate widget=%p name=%-12s id=0x%-6x",
+ _GetPrintCount(),
+ (void *) aWidget,
+ aWidgetName,
+ aWindowID);
+
+ if (aRect) {
+ fprintf(aFileOut,
+ " rect=%3d,%-3d %3d,%-3d",
+ aRect->x, aRect->y, aRect->width, aRect->height);
+ } else {
+ fprintf(aFileOut,
+ " rect=%-15s",
+ "none");
+ }
+
+ fprintf(aFileOut, "\n");
+}
+//////////////////////////////////////////////////////////////
+
+#endif // DEBUG