diff options
Diffstat (limited to 'widget/PuppetWidget.cpp')
| -rw-r--r-- | widget/PuppetWidget.cpp | 1186 |
1 files changed, 1186 insertions, 0 deletions
diff --git a/widget/PuppetWidget.cpp b/widget/PuppetWidget.cpp new file mode 100644 index 0000000000..86cb69ce64 --- /dev/null +++ b/widget/PuppetWidget.cpp @@ -0,0 +1,1186 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: sw=2 ts=8 et : + */ +/* 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 "base/basictypes.h" + +#include "gfxPlatform.h" +#include "nsRefreshDriver.h" +#include "mozilla/dom/BrowserChild.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/IMEStateManager.h" +#include "mozilla/layers/APZChild.h" +#include "mozilla/layers/WebRenderLayerManager.h" +#include "mozilla/NativeKeyBindingsType.h" +#include "mozilla/Preferences.h" +#include "mozilla/PresShell.h" +#include "mozilla/SchedulerGroup.h" +#include "mozilla/StaticPrefs_browser.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/TextComposition.h" +#include "mozilla/TextEventDispatcher.h" +#include "mozilla/TextEvents.h" +#include "mozilla/Unused.h" +#include "PuppetWidget.h" +#include "nsContentUtils.h" +#include "nsIWidgetListener.h" +#include "imgIContainer.h" +#include "nsView.h" +#include "nsXPLookAndFeel.h" +#include "nsPrintfCString.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::gfx; +using namespace mozilla::layers; +using namespace mozilla::widget; + +static void InvalidateRegion(nsIWidget* aWidget, + const LayoutDeviceIntRegion& aRegion) { + for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) { + aWidget->Invalidate(iter.Get()); + } +} + +/*static*/ +already_AddRefed<nsIWidget> nsIWidget::CreatePuppetWidget( + BrowserChild* aBrowserChild) { + MOZ_ASSERT(!aBrowserChild || nsIWidget::UsePuppetWidgets(), + "PuppetWidgets not allowed in this configuration"); + + nsCOMPtr<nsIWidget> widget = new PuppetWidget(aBrowserChild); + return widget.forget(); +} + +namespace mozilla { +namespace widget { + +static bool IsPopup(const widget::InitData* aInitData) { + return aInitData && aInitData->mWindowType == WindowType::Popup; +} + +static bool MightNeedIMEFocus(const widget::InitData* aInitData) { + // In the puppet-widget world, popup widgets are just dummies and + // shouldn't try to mess with IME state. +#ifdef MOZ_CROSS_PROCESS_IME + return !IsPopup(aInitData); +#else + return false; +#endif +} + +NS_IMPL_ISUPPORTS_INHERITED(PuppetWidget, nsBaseWidget, + TextEventDispatcherListener) + +PuppetWidget::PuppetWidget(BrowserChild* aBrowserChild) + : mBrowserChild(aBrowserChild), + mMemoryPressureObserver(nullptr), + mEnabled(false), + mVisible(false), + mSizeMode(nsSizeMode_Normal), + mNeedIMEStateInit(false), + mIgnoreCompositionEvents(false) { + // Setting 'Unknown' means "not yet cached". + mInputContext.mIMEState.mEnabled = IMEEnabled::Unknown; +} + +PuppetWidget::~PuppetWidget() { Destroy(); } + +void PuppetWidget::InfallibleCreate(nsIWidget* aParent, + nsNativeWidget aNativeParent, + const LayoutDeviceIntRect& aRect, + widget::InitData* aInitData) { + MOZ_ASSERT(!aNativeParent, "got a non-Puppet native parent"); + + BaseCreate(nullptr, aInitData); + + mBounds = aRect; + mEnabled = true; + mVisible = true; + + mDrawTarget = gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget( + IntSize(1, 1), SurfaceFormat::B8G8R8A8); + + mNeedIMEStateInit = MightNeedIMEFocus(aInitData); + + PuppetWidget* parent = static_cast<PuppetWidget*>(aParent); + if (parent) { + parent->SetChild(this); + mWindowRenderer = parent->GetWindowRenderer(); + } else { + Resize(mBounds.X(), mBounds.Y(), mBounds.Width(), mBounds.Height(), false); + } + mMemoryPressureObserver = MemoryPressureObserver::Create(this); +} + +nsresult PuppetWidget::Create(nsIWidget* aParent, nsNativeWidget aNativeParent, + const LayoutDeviceIntRect& aRect, + widget::InitData* aInitData) { + InfallibleCreate(aParent, aNativeParent, aRect, aInitData); + return NS_OK; +} + +void PuppetWidget::InitIMEState() { + MOZ_ASSERT(mBrowserChild); + if (mNeedIMEStateInit) { + mContentCache.Clear(); + mBrowserChild->SendUpdateContentCache(mContentCache); + mIMENotificationRequestsOfParent = IMENotificationRequests(); + mNeedIMEStateInit = false; + } +} + +already_AddRefed<nsIWidget> PuppetWidget::CreateChild( + const LayoutDeviceIntRect& aRect, widget::InitData* aInitData, + bool aForceUseIWidgetParent) { + bool isPopup = IsPopup(aInitData); + nsCOMPtr<nsIWidget> widget = nsIWidget::CreatePuppetWidget(mBrowserChild); + return ((widget && NS_SUCCEEDED(widget->Create(isPopup ? nullptr : this, + nullptr, aRect, aInitData))) + ? widget.forget() + : nullptr); +} + +void PuppetWidget::Destroy() { + if (mOnDestroyCalled) { + return; + } + mOnDestroyCalled = true; + + Base::OnDestroy(); + Base::Destroy(); + if (mMemoryPressureObserver) { + mMemoryPressureObserver->Unregister(); + mMemoryPressureObserver = nullptr; + } + mChild = nullptr; + if (mWindowRenderer) { + mWindowRenderer->Destroy(); + } + mWindowRenderer = nullptr; + mBrowserChild = nullptr; +} + +void PuppetWidget::Show(bool aState) { + NS_ASSERTION(mEnabled, + "does it make sense to Show()/Hide() a disabled widget?"); + + bool wasVisible = mVisible; + mVisible = aState; + + if (mChild) { + mChild->mVisible = aState; + } + + if (!wasVisible && mVisible) { + // The previously attached widget listener is handy if + // we're transitioning from page to page without dropping + // layers (since we'll continue to show the old layers + // associated with that old widget listener). If the + // PuppetWidget was hidden, those layers are dropped, + // so the previously attached widget listener is really + // of no use anymore (and is actually actively harmful - see + // bug 1323586). + mPreviouslyAttachedWidgetListener = nullptr; + Resize(mBounds.Width(), mBounds.Height(), false); + Invalidate(mBounds); + } +} + +void PuppetWidget::Resize(double aWidth, double aHeight, bool aRepaint) { + LayoutDeviceIntRect oldBounds = mBounds; + mBounds.SizeTo( + LayoutDeviceIntSize(NSToIntRound(aWidth), NSToIntRound(aHeight))); + + if (mChild) { + mChild->Resize(aWidth, aHeight, aRepaint); + return; + } + + // XXX: roc says that |aRepaint| dictates whether or not to + // invalidate the expanded area + if (oldBounds.Size() < mBounds.Size() && aRepaint) { + LayoutDeviceIntRegion dirty(mBounds); + dirty.Sub(dirty, oldBounds); + InvalidateRegion(this, dirty); + } + + // call WindowResized() on both the current listener, and possibly + // also the previous one if we're in a state where we're drawing that one + // because the current one is paint suppressed + if (!oldBounds.IsEqualEdges(mBounds) && mAttachedWidgetListener) { + if (GetCurrentWidgetListener() && + GetCurrentWidgetListener() != mAttachedWidgetListener) { + GetCurrentWidgetListener()->WindowResized(this, mBounds.Width(), + mBounds.Height()); + } + mAttachedWidgetListener->WindowResized(this, mBounds.Width(), + mBounds.Height()); + } +} + +void PuppetWidget::SetFocus(Raise aRaise, CallerType aCallerType) { + if (aRaise == Raise::Yes && mBrowserChild) { + mBrowserChild->SendRequestFocus(true, aCallerType); + } +} + +void PuppetWidget::Invalidate(const LayoutDeviceIntRect& aRect) { +#ifdef DEBUG + debug_DumpInvalidate(stderr, this, &aRect, "PuppetWidget", 0); +#endif + + if (mChild) { + mChild->Invalidate(aRect); + return; + } + + if (mBrowserChild && !aRect.IsEmpty() && !mWidgetPaintTask.IsPending()) { + mWidgetPaintTask = new WidgetPaintTask(this); + nsCOMPtr<nsIRunnable> event(mWidgetPaintTask.get()); + SchedulerGroup::Dispatch(TaskCategory::Other, event.forget()); + } +} + +mozilla::LayoutDeviceToLayoutDeviceMatrix4x4 +PuppetWidget::WidgetToTopLevelWidgetTransform() { + if (!GetOwningBrowserChild()) { + NS_WARNING("PuppetWidget without Tab does not have transform information."); + return mozilla::LayoutDeviceToLayoutDeviceMatrix4x4(); + } + return GetOwningBrowserChild()->GetChildToParentConversionMatrix(); +} + +void PuppetWidget::InitEvent(WidgetGUIEvent& aEvent, + LayoutDeviceIntPoint* aPoint) { + if (nullptr == aPoint) { + aEvent.mRefPoint = LayoutDeviceIntPoint(0, 0); + } else { + // use the point override if provided + aEvent.mRefPoint = *aPoint; + } +} + +nsresult PuppetWidget::DispatchEvent(WidgetGUIEvent* aEvent, + nsEventStatus& aStatus) { +#ifdef DEBUG + debug_DumpEvent(stdout, aEvent->mWidget, aEvent, "PuppetWidget", 0); +#endif + + MOZ_ASSERT(!mChild || mChild->mWindowType == WindowType::Popup, + "Unexpected event dispatch!"); + + MOZ_ASSERT(!aEvent->AsKeyboardEvent() || + aEvent->mFlags.mIsSynthesizedForTests || + aEvent->AsKeyboardEvent()->AreAllEditCommandsInitialized(), + "Non-sysnthesized keyboard events should have edit commands for " + "all types " + "before dispatched"); + + if (aEvent->mClass == eCompositionEventClass) { + // If we've already requested to commit/cancel the latest composition, + // TextComposition for the old composition has been destroyed. Then, + // the DOM tree needs to listen to next eCompositionStart and its + // following events. So, until we meet new eCompositionStart, let's + // discard all unnecessary composition events here. + if (mIgnoreCompositionEvents) { + if (aEvent->mMessage != eCompositionStart) { + aStatus = nsEventStatus_eIgnore; + return NS_OK; + } + // Now, we receive new eCompositionStart. Let's restart to handle + // composition in this process. + mIgnoreCompositionEvents = false; + } + // Store the latest native IME context of parent process's widget or + // TextEventDispatcher if it's in this process. + WidgetCompositionEvent* compositionEvent = aEvent->AsCompositionEvent(); +#ifdef DEBUG + if (mNativeIMEContext.IsValid() && + mNativeIMEContext != compositionEvent->mNativeIMEContext) { + RefPtr<TextComposition> composition = + IMEStateManager::GetTextCompositionFor(this); + MOZ_ASSERT( + !composition, + "When there is composition caused by old native IME context, " + "composition events caused by different native IME context are not " + "allowed"); + } +#endif // #ifdef DEBUG + mNativeIMEContext = compositionEvent->mNativeIMEContext; + mContentCache.OnCompositionEvent(*compositionEvent); + } + + // If the event is a composition event or a keyboard event, it should be + // dispatched with TextEventDispatcher if we could do that with current + // design. However, we cannot do that without big changes and the behavior + // is not so complicated for now. Therefore, we should just notify it + // of dispatching events and TextEventDispatcher should emulate the state + // with events here. + if (aEvent->mClass == eCompositionEventClass || + aEvent->mClass == eKeyboardEventClass) { + TextEventDispatcher* dispatcher = GetTextEventDispatcher(); + // However, if the event is being dispatched by the text event dispatcher + // or, there is native text event dispatcher listener, that means that + // native text input event handler is in this process like on Android, + // and the event is not synthesized for tests, the event is coming from + // the TextEventDispatcher. In these cases, we shouldn't notify + // TextEventDispatcher of dispatching the event. + if (!dispatcher->IsDispatchingEvent() && + !(mNativeTextEventDispatcherListener && + !aEvent->mFlags.mIsSynthesizedForTests)) { + DebugOnly<nsresult> rv = + dispatcher->BeginInputTransactionFor(aEvent, this); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "The text event dispatcher should always succeed to start input " + "transaction for the event"); + } + } + + aStatus = nsEventStatus_eIgnore; + + if (GetCurrentWidgetListener()) { + aStatus = + GetCurrentWidgetListener()->HandleEvent(aEvent, mUseAttachedEvents); + } + + return NS_OK; +} + +nsIWidget::ContentAndAPZEventStatus PuppetWidget::DispatchInputEvent( + WidgetInputEvent* aEvent) { + ContentAndAPZEventStatus status; + if (!AsyncPanZoomEnabled()) { + DispatchEvent(aEvent, status.mContentStatus); + return status; + } + + if (!mBrowserChild) { + return status; + } + + switch (aEvent->mClass) { + case eWheelEventClass: + Unused << mBrowserChild->SendDispatchWheelEvent(*aEvent->AsWheelEvent()); + break; + case eMouseEventClass: + Unused << mBrowserChild->SendDispatchMouseEvent(*aEvent->AsMouseEvent()); + break; + case eKeyboardEventClass: + Unused << mBrowserChild->SendDispatchKeyboardEvent( + *aEvent->AsKeyboardEvent()); + break; + case eTouchEventClass: + Unused << mBrowserChild->SendDispatchTouchEvent(*aEvent->AsTouchEvent()); + break; + default: + MOZ_ASSERT_UNREACHABLE("unsupported event type"); + } + + return status; +} + +nsresult PuppetWidget::SynthesizeNativeKeyEvent( + int32_t aNativeKeyboardLayout, int32_t aNativeKeyCode, + uint32_t aModifierFlags, const nsAString& aCharacters, + const nsAString& aUnmodifiedCharacters, nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "keyevent"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeKeyEvent( + aNativeKeyboardLayout, aNativeKeyCode, aModifierFlags, aCharacters, + aUnmodifiedCharacters, notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeMouseEvent( + mozilla::LayoutDeviceIntPoint aPoint, NativeMouseMessage aNativeMessage, + MouseButton aButton, nsIWidget::Modifiers aModifierFlags, + nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "mouseevent"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeMouseEvent( + aPoint, static_cast<uint32_t>(aNativeMessage), + static_cast<int16_t>(aButton), static_cast<uint32_t>(aModifierFlags), + notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeMouseMove( + mozilla::LayoutDeviceIntPoint aPoint, nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "mousemove"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeMouseMove(aPoint, notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeMouseScrollEvent( + mozilla::LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage, + double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aModifierFlags, + uint32_t aAdditionalFlags, nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "mousescrollevent"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeMouseScrollEvent( + aPoint, aNativeMessage, aDeltaX, aDeltaY, aDeltaZ, aModifierFlags, + aAdditionalFlags, notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeTouchPoint( + uint32_t aPointerId, TouchPointerState aPointerState, + LayoutDeviceIntPoint aPoint, double aPointerPressure, + uint32_t aPointerOrientation, nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "touchpoint"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeTouchPoint( + aPointerId, aPointerState, aPoint, aPointerPressure, aPointerOrientation, + notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeTouchPadPinch( + TouchpadGesturePhase aEventPhase, float aScale, LayoutDeviceIntPoint aPoint, + int32_t aModifierFlags) { + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeTouchPadPinch(aEventPhase, aScale, aPoint, + aModifierFlags); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint, + bool aLongTap, + nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "touchtap"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeTouchTap(aPoint, aLongTap, + notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::ClearNativeTouchSequence(nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "cleartouch"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendClearNativeTouchSequence(notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativePenInput( + uint32_t aPointerId, TouchPointerState aPointerState, + LayoutDeviceIntPoint aPoint, double aPressure, uint32_t aRotation, + int32_t aTiltX, int32_t aTiltY, int32_t aButton, nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "peninput"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativePenInput( + aPointerId, aPointerState, aPoint, aPressure, aRotation, aTiltX, aTiltY, + aButton, notifier.SaveObserver()); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeTouchpadDoubleTap( + LayoutDeviceIntPoint aPoint, uint32_t aModifierFlags) { + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeTouchpadDoubleTap(aPoint, aModifierFlags); + return NS_OK; +} + +nsresult PuppetWidget::SynthesizeNativeTouchpadPan( + TouchpadGesturePhase aEventPhase, LayoutDeviceIntPoint aPoint, + double aDeltaX, double aDeltaY, int32_t aModifierFlags, + nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "touchpadpanevent"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendSynthesizeNativeTouchpadPan(aEventPhase, aPoint, aDeltaX, + aDeltaY, aModifierFlags, + notifier.SaveObserver()); + return NS_OK; +} + +void PuppetWidget::LockNativePointer() { + if (!mBrowserChild) { + return; + } + mBrowserChild->SendLockNativePointer(); +} + +void PuppetWidget::UnlockNativePointer() { + if (!mBrowserChild) { + return; + } + mBrowserChild->SendUnlockNativePointer(); +} + +void PuppetWidget::SetConfirmedTargetAPZC( + uint64_t aInputBlockId, + const nsTArray<ScrollableLayerGuid>& aTargets) const { + if (mBrowserChild) { + mBrowserChild->SetTargetAPZC(aInputBlockId, aTargets); + } +} + +void PuppetWidget::UpdateZoomConstraints( + const uint32_t& aPresShellId, const ScrollableLayerGuid::ViewID& aViewId, + const Maybe<ZoomConstraints>& aConstraints) { + if (mBrowserChild) { + mBrowserChild->DoUpdateZoomConstraints(aPresShellId, aViewId, aConstraints); + } +} + +bool PuppetWidget::AsyncPanZoomEnabled() const { + return mBrowserChild && mBrowserChild->AsyncPanZoomEnabled(); +} + +bool PuppetWidget::GetEditCommands(NativeKeyBindingsType aType, + const WidgetKeyboardEvent& aEvent, + nsTArray<CommandInt>& aCommands) { + MOZ_ASSERT(!aEvent.mFlags.mIsSynthesizedForTests); + // Validate the arguments. + if (NS_WARN_IF(!nsIWidget::GetEditCommands(aType, aEvent, aCommands))) { + return false; + } + if (NS_WARN_IF(!mBrowserChild)) { + return false; + } + mBrowserChild->RequestEditCommands(aType, aEvent, aCommands); + return true; +} + +WindowRenderer* PuppetWidget::GetWindowRenderer() { + if (!mWindowRenderer) { + if (XRE_IsParentProcess()) { + // On the parent process there is no CompositorBridgeChild which confuses + // some layers code, so we use basic layers instead. Note that we create + mWindowRenderer = new FallbackRenderer; + return mWindowRenderer; + } + + // If we know for sure that the parent side of this BrowserChild is not + // connected to the compositor, we don't want to use a "remote" layer + // manager like WebRender or Client. Instead we use a Basic one which + // can do drawing in this process. + MOZ_ASSERT(!mBrowserChild || + mBrowserChild->IsLayersConnected() != Some(true)); + mWindowRenderer = CreateFallbackRenderer(); + } + + return mWindowRenderer; +} + +bool PuppetWidget::CreateRemoteLayerManager( + const std::function<bool(WebRenderLayerManager*)>& aInitializeFunc) { + RefPtr<WebRenderLayerManager> lm = new WebRenderLayerManager(this); + MOZ_ASSERT(mBrowserChild); + + if (!aInitializeFunc(lm)) { + return false; + } + + // Force the old LM to self destruct, otherwise if the reference dangles we + // could fail to revoke the most recent transaction. We only want to replace + // it if we successfully create its successor because a partially initialized + // layer manager is worse than a fully initialized but shutdown layer manager. + DestroyLayerManager(); + mWindowRenderer = std::move(lm); + return true; +} + +nsresult PuppetWidget::RequestIMEToCommitComposition(bool aCancel) { + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + + MOZ_ASSERT(!Destroyed()); + + // There must not be composition which is caused by the PuppetWidget instance. + if (NS_WARN_IF(!mNativeIMEContext.IsValid())) { + return NS_OK; + } + + // We've already requested to commit/cancel composition. + if (NS_WARN_IF(mIgnoreCompositionEvents)) { +#ifdef DEBUG + RefPtr<TextComposition> composition = + IMEStateManager::GetTextCompositionFor(this); + MOZ_ASSERT(!composition); +#endif // #ifdef DEBUG + return NS_OK; + } + + RefPtr<TextComposition> composition = + IMEStateManager::GetTextCompositionFor(this); + // This method shouldn't be called when there is no text composition instance. + if (NS_WARN_IF(!composition)) { + return NS_OK; + } + + MOZ_DIAGNOSTIC_ASSERT( + composition->IsRequestingCommitOrCancelComposition(), + "Requesting commit or cancel composition should be requested via " + "TextComposition instance"); + + bool isCommitted = false; + nsAutoString committedString; + if (NS_WARN_IF(!mBrowserChild->SendRequestIMEToCommitComposition( + aCancel, &isCommitted, &committedString))) { + return NS_ERROR_FAILURE; + } + + // If the composition wasn't committed synchronously, we need to wait async + // composition events for destroying the TextComposition instance. + if (!isCommitted) { + return NS_OK; + } + + // Dispatch eCompositionCommit event. + WidgetCompositionEvent compositionCommitEvent(true, eCompositionCommit, this); + InitEvent(compositionCommitEvent, nullptr); + compositionCommitEvent.mData = committedString; + nsEventStatus status = nsEventStatus_eIgnore; + DispatchEvent(&compositionCommitEvent, status); + +#ifdef DEBUG + RefPtr<TextComposition> currentComposition = + IMEStateManager::GetTextCompositionFor(this); + MOZ_ASSERT(!currentComposition); +#endif // #ifdef DEBUG + + // Ignore the following composition events until we receive new + // eCompositionStart event. + mIgnoreCompositionEvents = true; + + Unused << mBrowserChild->SendOnEventNeedingAckHandled( + eCompositionCommitRequestHandled); + + // NOTE: PuppetWidget might be destroyed already. + return NS_OK; +} + +// When this widget caches input context and currently managed by +// IMEStateManager, the cache is valid. +bool PuppetWidget::HaveValidInputContextCache() const { + return (mInputContext.mIMEState.mEnabled != IMEEnabled::Unknown && + IMEStateManager::GetWidgetForActiveInputContext() == this); +} + +nsRefreshDriver* PuppetWidget::GetTopLevelRefreshDriver() const { + if (!mBrowserChild) { + return nullptr; + } + + if (PresShell* presShell = mBrowserChild->GetTopLevelPresShell()) { + return presShell->GetRefreshDriver(); + } + + return nullptr; +} + +void PuppetWidget::SetInputContext(const InputContext& aContext, + const InputContextAction& aAction) { + mInputContext = aContext; + // Any widget instances cannot cache IME open state because IME open state + // can be changed by user but native IME may not notify us of changing the + // open state on some platforms. + mInputContext.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED; + if (!mBrowserChild) { + return; + } + mBrowserChild->SendSetInputContext(aContext, aAction); +} + +InputContext PuppetWidget::GetInputContext() { + // XXX Currently, we don't support retrieving IME open state from child + // process. + + // If the cache of input context is valid, we can avoid to use synchronous + // IPC. + if (HaveValidInputContextCache()) { + return mInputContext; + } + + NS_WARNING("PuppetWidget::GetInputContext() needs to retrieve it with IPC"); + + // Don't cache InputContext here because this process isn't managing IME + // state of the chrome widget. So, we cannot modify mInputContext when + // chrome widget is set to new context. + InputContext context; + if (mBrowserChild) { + mBrowserChild->SendGetInputContext(&context.mIMEState); + } + return context; +} + +NativeIMEContext PuppetWidget::GetNativeIMEContext() { + return mNativeIMEContext; +} + +nsresult PuppetWidget::NotifyIMEOfFocusChange( + const IMENotification& aIMENotification) { + MOZ_ASSERT(IMEStateManager::CanSendNotificationToWidget()); + + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + + bool gotFocus = aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS; + if (gotFocus) { + // When IME gets focus, we should initialize all information of the + // content, however, it may fail to get it because the editor may have + // already been blurred. + if (NS_WARN_IF(!mContentCache.CacheAll(this, &aIMENotification))) { + return NS_ERROR_FAILURE; + } + } else { + // When IME loses focus, we don't need to store anything. + mContentCache.Clear(); + } + + mIMENotificationRequestsOfParent = + IMENotificationRequests(IMENotificationRequests::NOTIFY_ALL); + RefPtr<PuppetWidget> self = this; + mBrowserChild->SendNotifyIMEFocus(mContentCache, aIMENotification) + ->Then( + GetMainThreadSerialEventTarget(), __func__, + [self](IMENotificationRequests&& aRequests) { + self->mIMENotificationRequestsOfParent = aRequests; + if (TextEventDispatcher* dispatcher = + self->GetTextEventDispatcher()) { + dispatcher->OnWidgetChangeIMENotificationRequests(self); + } + }, + [self](mozilla::ipc::ResponseRejectReason&& aReason) { + NS_WARNING("SendNotifyIMEFocus got rejected."); + }); + + return NS_OK; +} + +nsresult PuppetWidget::NotifyIMEOfCompositionUpdate( + const IMENotification& aIMENotification) { + MOZ_ASSERT(IMEStateManager::CanSendNotificationToWidget()); + + if (NS_WARN_IF(!mBrowserChild)) { + return NS_ERROR_FAILURE; + } + + if (NS_WARN_IF( + !mContentCache.CacheCaretAndTextRects(this, &aIMENotification))) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendNotifyIMECompositionUpdate(mContentCache, + aIMENotification); + return NS_OK; +} + +nsresult PuppetWidget::NotifyIMEOfTextChange( + const IMENotification& aIMENotification) { + MOZ_ASSERT(IMEStateManager::CanSendNotificationToWidget()); + MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_TEXT_CHANGE, + "Passed wrong notification"); + + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + + // FYI: text change notification is the first notification after + // a user operation changes the content. So, we need to modify + // the cache as far as possible here. + + if (NS_WARN_IF(!mContentCache.CacheText(this, &aIMENotification))) { + return NS_ERROR_FAILURE; + } + + // BrowserParent doesn't this this to cache. we don't send the notification + // if parent process doesn't request NOTIFY_TEXT_CHANGE. + if (mIMENotificationRequestsOfParent.WantTextChange()) { + mBrowserChild->SendNotifyIMETextChange(mContentCache, aIMENotification); + } else { + mBrowserChild->SendUpdateContentCache(mContentCache); + } + return NS_OK; +} + +nsresult PuppetWidget::NotifyIMEOfSelectionChange( + const IMENotification& aIMENotification) { + MOZ_ASSERT(IMEStateManager::CanSendNotificationToWidget()); + MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_SELECTION_CHANGE, + "Passed wrong notification"); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + + // Note that selection change must be notified after text change if it occurs. + // Therefore, we don't need to query text content again here. + if (MOZ_UNLIKELY(!mContentCache.SetSelection( + this, aIMENotification.mSelectionChangeData))) { + // If there is no text cache yet, caching text will cache selection too. + // Therefore, in the case, we don't need to notify IME of selection change + // right now. + return NS_OK; + } + + mBrowserChild->SendNotifyIMESelection(mContentCache, aIMENotification); + + return NS_OK; +} + +nsresult PuppetWidget::NotifyIMEOfMouseButtonEvent( + const IMENotification& aIMENotification) { + MOZ_ASSERT(IMEStateManager::CanSendNotificationToWidget()); + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + + bool consumedByIME = false; + if (!mBrowserChild->SendNotifyIMEMouseButtonEvent(aIMENotification, + &consumedByIME)) { + return NS_ERROR_FAILURE; + } + + return consumedByIME ? NS_SUCCESS_EVENT_CONSUMED : NS_OK; +} + +nsresult PuppetWidget::NotifyIMEOfPositionChange( + const IMENotification& aIMENotification) { + MOZ_ASSERT(IMEStateManager::CanSendNotificationToWidget()); + if (NS_WARN_IF(!mBrowserChild)) { + return NS_ERROR_FAILURE; + } + + if (NS_WARN_IF(!mContentCache.CacheEditorRect(this, &aIMENotification))) { + return NS_ERROR_FAILURE; + } + if (NS_WARN_IF( + !mContentCache.CacheCaretAndTextRects(this, &aIMENotification))) { + return NS_ERROR_FAILURE; + } + if (mIMENotificationRequestsOfParent.WantPositionChanged()) { + mBrowserChild->SendNotifyIMEPositionChange(mContentCache, aIMENotification); + } else { + mBrowserChild->SendUpdateContentCache(mContentCache); + } + return NS_OK; +} + +struct CursorSurface { + UniquePtr<char[]> mData; + IntSize mSize; +}; + +void PuppetWidget::SetCursor(const Cursor& aCursor) { + if (!mBrowserChild) { + return; + } + + const bool force = mUpdateCursor; + if (!force && mCursor == aCursor) { + return; + } + + bool hasCustomCursor = false; + Maybe<mozilla::ipc::BigBuffer> customCursorData; + size_t length = 0; + IntSize customCursorSize; + int32_t stride = 0; + auto format = SurfaceFormat::B8G8R8A8; + ImageResolution resolution = aCursor.mResolution; + if (aCursor.IsCustom()) { + int32_t width = 0, height = 0; + aCursor.mContainer->GetWidth(&width); + aCursor.mContainer->GetHeight(&height); + const int32_t flags = + imgIContainer::FLAG_SYNC_DECODE | imgIContainer::FLAG_ASYNC_NOTIFY; + RefPtr<SourceSurface> surface; + if (width && height && + aCursor.mContainer->GetType() == imgIContainer::TYPE_VECTOR) { + // For vector images, scale to device pixels. + resolution.ScaleBy(GetDefaultScale().scale); + resolution.ApplyInverseTo(width, height); + surface = aCursor.mContainer->GetFrameAtSize( + {width, height}, imgIContainer::FRAME_CURRENT, flags); + } else { + // NOTE(emilio): We get the frame at the full size, ignoring resolution, + // because we're going to rasterize it, and we'd effectively lose the + // extra pixels if we rasterized to CustomCursorSize. + surface = + aCursor.mContainer->GetFrame(imgIContainer::FRAME_CURRENT, flags); + } + if (surface) { + if (RefPtr<DataSourceSurface> dataSurface = surface->GetDataSurface()) { + hasCustomCursor = true; + customCursorData = + nsContentUtils::GetSurfaceData(*dataSurface, &length, &stride); + customCursorSize = dataSurface->GetSize(); + format = dataSurface->GetFormat(); + } + } + } + + if (!mBrowserChild->SendSetCursor( + aCursor.mDefaultCursor, hasCustomCursor, std::move(customCursorData), + customCursorSize.width, customCursorSize.height, resolution.mX, + resolution.mY, stride, format, aCursor.mHotspotX, aCursor.mHotspotY, + force)) { + return; + } + mCursor = aCursor; + mUpdateCursor = false; +} + +void PuppetWidget::SetChild(PuppetWidget* aChild) { + MOZ_ASSERT(this != aChild, "can't parent a widget to itself"); + MOZ_ASSERT(!aChild->mChild, + "fake widget 'hierarchy' only expected to have one level"); + + mChild = aChild; +} + +NS_IMETHODIMP +PuppetWidget::WidgetPaintTask::Run() { + if (mWidget) { + mWidget->Paint(); + } + return NS_OK; +} + +void PuppetWidget::Paint() { + if (!GetCurrentWidgetListener()) return; + + mWidgetPaintTask.Revoke(); + + RefPtr<PuppetWidget> strongThis(this); + + GetCurrentWidgetListener()->WillPaintWindow(this); + + if (GetCurrentWidgetListener()) { + GetCurrentWidgetListener()->DidPaintWindow(); + } +} + +void PuppetWidget::PaintNowIfNeeded() { + if (IsVisible() && mWidgetPaintTask.IsPending()) { + Paint(); + } +} + +void PuppetWidget::OnMemoryPressure(layers::MemoryPressureReason aWhy) { + if (aWhy != MemoryPressureReason::LOW_MEMORY_ONGOING && !mVisible && + mWindowRenderer && mWindowRenderer->AsWebRender() && + XRE_IsContentProcess()) { + mWindowRenderer->AsWebRender()->ClearCachedResources(); + } +} + +bool PuppetWidget::NeedsPaint() { + // e10s popups are handled by the parent process, so never should be painted + // here + if (XRE_IsContentProcess() && + StaticPrefs::browser_tabs_remote_desktopbehavior() && + mWindowType == WindowType::Popup) { + NS_WARNING("Trying to paint an e10s popup in the child process!"); + return false; + } + + return mVisible; +} + +LayoutDeviceIntPoint PuppetWidget::GetChromeOffset() { + if (!GetOwningBrowserChild()) { + NS_WARNING("PuppetWidget without Tab does not have chrome information."); + return LayoutDeviceIntPoint(); + } + return GetOwningBrowserChild()->GetChromeOffset(); +} + +LayoutDeviceIntPoint PuppetWidget::WidgetToScreenOffset() { + return GetWindowPosition() + WidgetToTopLevelWidgetOffset(); +} + +LayoutDeviceIntPoint PuppetWidget::GetWindowPosition() { + if (!GetOwningBrowserChild()) { + return LayoutDeviceIntPoint(); + } + + int32_t winX, winY, winW, winH; + NS_ENSURE_SUCCESS(GetOwningBrowserChild()->GetDimensions( + DimensionKind::Outer, &winX, &winY, &winW, &winH), + LayoutDeviceIntPoint()); + return LayoutDeviceIntPoint(winX, winY) + + GetOwningBrowserChild()->GetClientOffset(); +} + +LayoutDeviceIntRect PuppetWidget::GetScreenBounds() { + return LayoutDeviceIntRect(WidgetToScreenOffset(), mBounds.Size()); +} + +uint32_t PuppetWidget::GetMaxTouchPoints() const { + return mBrowserChild ? mBrowserChild->MaxTouchPoints() : 0; +} + +void PuppetWidget::StartAsyncScrollbarDrag( + const AsyncDragMetrics& aDragMetrics) { + mBrowserChild->StartScrollbarDrag(aDragMetrics); +} + +ScreenIntMargin PuppetWidget::GetSafeAreaInsets() const { + return mSafeAreaInsets; +} + +void PuppetWidget::UpdateSafeAreaInsets( + const ScreenIntMargin& aSafeAreaInsets) { + mSafeAreaInsets = aSafeAreaInsets; +} + +nsIWidgetListener* PuppetWidget::GetCurrentWidgetListener() { + if (!mPreviouslyAttachedWidgetListener || !mAttachedWidgetListener) { + return mAttachedWidgetListener; + } + + if (mAttachedWidgetListener->GetView()->IsPrimaryFramePaintSuppressed()) { + return mPreviouslyAttachedWidgetListener; + } + + return mAttachedWidgetListener; +} + +void PuppetWidget::ZoomToRect(const uint32_t& aPresShellId, + const ScrollableLayerGuid::ViewID& aViewId, + const CSSRect& aRect, const uint32_t& aFlags) { + if (!mBrowserChild) { + return; + } + + mBrowserChild->ZoomToRect(aPresShellId, aViewId, aRect, aFlags); +} + +void PuppetWidget::LookUpDictionary( + const nsAString& aText, const nsTArray<mozilla::FontRange>& aFontRangeArray, + const bool aIsVertical, const LayoutDeviceIntPoint& aPoint) { + if (!mBrowserChild) { + return; + } + + mBrowserChild->SendLookUpDictionary(aText, aFontRangeArray, aIsVertical, + aPoint); +} + +bool PuppetWidget::HasPendingInputEvent() { + if (!mBrowserChild) { + return false; + } + + bool ret = false; + + mBrowserChild->GetIPCChannel()->PeekMessages( + [&ret](const IPC::Message& aMsg) -> bool { + if (nsContentUtils::IsMessageInputEvent(aMsg)) { + ret = true; + return false; // Stop peeking. + } + return true; + }); + + return ret; +} + +// TextEventDispatcherListener + +NS_IMETHODIMP +PuppetWidget::NotifyIME(TextEventDispatcher* aTextEventDispatcher, + const IMENotification& aIMENotification) { + MOZ_ASSERT(aTextEventDispatcher == mTextEventDispatcher); + + // If there is different text event dispatcher listener for handling + // text event dispatcher, that means that native keyboard events and + // IME events are handled in this process. Therefore, we don't need + // to send any requests and notifications to the parent process. + if (mNativeTextEventDispatcherListener) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + switch (aIMENotification.mMessage) { + case REQUEST_TO_COMMIT_COMPOSITION: + return RequestIMEToCommitComposition(false); + case REQUEST_TO_CANCEL_COMPOSITION: + return RequestIMEToCommitComposition(true); + case NOTIFY_IME_OF_FOCUS: + case NOTIFY_IME_OF_BLUR: + return NotifyIMEOfFocusChange(aIMENotification); + case NOTIFY_IME_OF_SELECTION_CHANGE: + return NotifyIMEOfSelectionChange(aIMENotification); + case NOTIFY_IME_OF_TEXT_CHANGE: + return NotifyIMEOfTextChange(aIMENotification); + case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED: + return NotifyIMEOfCompositionUpdate(aIMENotification); + case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT: + return NotifyIMEOfMouseButtonEvent(aIMENotification); + case NOTIFY_IME_OF_POSITION_CHANGE: + return NotifyIMEOfPositionChange(aIMENotification); + default: + return NS_ERROR_NOT_IMPLEMENTED; + } +} + +NS_IMETHODIMP_(IMENotificationRequests) +PuppetWidget::GetIMENotificationRequests() { + return IMENotificationRequests( + mIMENotificationRequestsOfParent.mWantUpdates | + IMENotificationRequests::NOTIFY_TEXT_CHANGE | + IMENotificationRequests::NOTIFY_POSITION_CHANGE); +} + +NS_IMETHODIMP_(void) +PuppetWidget::OnRemovedFrom(TextEventDispatcher* aTextEventDispatcher) { + MOZ_ASSERT(aTextEventDispatcher == mTextEventDispatcher); +} + +NS_IMETHODIMP_(void) +PuppetWidget::WillDispatchKeyboardEvent( + TextEventDispatcher* aTextEventDispatcher, + WidgetKeyboardEvent& aKeyboardEvent, uint32_t aIndexOfKeypress, + void* aData) { + MOZ_ASSERT(aTextEventDispatcher == mTextEventDispatcher); +} + +nsresult PuppetWidget::SetSystemFont(const nsCString& aFontName) { + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + + mBrowserChild->SendSetSystemFont(aFontName); + return NS_OK; +} + +nsresult PuppetWidget::GetSystemFont(nsCString& aFontName) { + if (!mBrowserChild) { + return NS_ERROR_FAILURE; + } + mBrowserChild->SendGetSystemFont(&aFontName); + return NS_OK; +} + +} // namespace widget +} // namespace mozilla |