diff options
Diffstat (limited to 'widget/nsBaseWidget.cpp')
| -rw-r--r-- | widget/nsBaseWidget.cpp | 3326 |
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(¤tRects); + // 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 |