--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -1561,19 +1561,21 @@ mozilla::ipc::IPCResult
TabChild::RecvMouseEvent(const nsString& aType,
const float& aX,
const float& aY,
const int32_t& aButton,
const int32_t& aClickCount,
const int32_t& aModifiers,
const bool& aIgnoreRootScrollFrame)
{
- APZCCallbackHelper::DispatchMouseEvent(GetPresShell(), aType, CSSPoint(aX, aY),
- aButton, aClickCount, aModifiers, aIgnoreRootScrollFrame,
- nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN, 0 /* Use the default value here. */);
+ APZCCallbackHelper::DispatchMouseEvent(GetPresShell(), aType,
+ CSSPoint(aX, aY), aButton, aClickCount,
+ aModifiers, aIgnoreRootScrollFrame,
+ nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN,
+ 0 /* Use the default value here. */);
return IPC_OK();
}
mozilla::ipc::IPCResult
TabChild::RecvRealMouseMoveEvent(const WidgetMouseEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId)
{
@@ -1598,23 +1600,25 @@ mozilla::ipc::IPCResult
TabChild::RecvRealMouseButtonEvent(const WidgetMouseEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId)
{
// Mouse events like eMouseEnterIntoWidget, that are created in the parent
// process EventStateManager code, have an input block id which they get from
// the InputAPZContext in the parent process stack. However, they did not
// actually go through the APZ code and so their mHandledByAPZ flag is false.
- // Since thos events didn't go through APZ, we don't need to send notifications
- // for them.
+ // Since thos events didn't go through APZ, we don't need to send
+ // notifications for them.
bool pendingLayerization = false;
if (aInputBlockId && aEvent.mFlags.mHandledByAPZ) {
nsCOMPtr<nsIDocument> document(GetDocument());
- pendingLayerization = APZCCallbackHelper::SendSetTargetAPZCNotification(
- mPuppetWidget, document, aEvent, aGuid, aInputBlockId);
+ pendingLayerization =
+ APZCCallbackHelper::SendSetTargetAPZCNotification(mPuppetWidget, document,
+ aEvent, aGuid,
+ aInputBlockId);
}
nsEventStatus unused;
InputAPZContext context(aGuid, aInputBlockId, unused);
if (pendingLayerization) {
context.SetPendingLayerization();
}
@@ -1639,17 +1643,17 @@ TabChild::RecvMouseWheelEvent(const Widg
nsCOMPtr<nsIDocument> document(GetDocument());
APZCCallbackHelper::SendSetTargetAPZCNotification(
mPuppetWidget, document, aEvent, aGuid, aInputBlockId);
}
WidgetWheelEvent localEvent(aEvent);
localEvent.mWidget = mPuppetWidget;
APZCCallbackHelper::ApplyCallbackTransform(localEvent, aGuid,
- mPuppetWidget->GetDefaultScale());
+ mPuppetWidget->GetDefaultScale());
APZCCallbackHelper::DispatchWidgetEvent(localEvent);
if (localEvent.mCanTriggerSwipe) {
SendRespondStartSwipeEvent(aInputBlockId, localEvent.TriggersSwipe());
}
if (aInputBlockId && aEvent.mFlags.mHandledByAPZ) {
mAPZEventState->ProcessWheelEvent(localEvent, aGuid, aInputBlockId);
@@ -1664,40 +1668,42 @@ TabChild::RecvRealTouchEvent(const Widge
const nsEventStatus& aApzResponse)
{
TABC_LOG("Receiving touch event of type %d\n", aEvent.mMessage);
WidgetTouchEvent localEvent(aEvent);
localEvent.mWidget = mPuppetWidget;
APZCCallbackHelper::ApplyCallbackTransform(localEvent, aGuid,
- mPuppetWidget->GetDefaultScale());
+ mPuppetWidget->GetDefaultScale());
if (localEvent.mMessage == eTouchStart && AsyncPanZoomEnabled()) {
nsCOMPtr<nsIDocument> document = GetDocument();
if (gfxPrefs::TouchActionEnabled()) {
- APZCCallbackHelper::SendSetAllowedTouchBehaviorNotification(mPuppetWidget,
- document, localEvent, aInputBlockId, mSetAllowedTouchBehaviorCallback);
+ APZCCallbackHelper::SendSetAllowedTouchBehaviorNotification(
+ mPuppetWidget, document, localEvent, aInputBlockId,
+ mSetAllowedTouchBehaviorCallback);
}
APZCCallbackHelper::SendSetTargetAPZCNotification(mPuppetWidget, document,
- localEvent, aGuid, aInputBlockId);
+ localEvent, aGuid,
+ aInputBlockId);
}
// Dispatch event to content (potentially a long-running operation)
nsEventStatus status = APZCCallbackHelper::DispatchWidgetEvent(localEvent);
if (!AsyncPanZoomEnabled()) {
// We shouldn't have any e10s platforms that have touch events enabled
// without APZ.
MOZ_ASSERT(false);
return IPC_OK();
}
mAPZEventState->ProcessTouchEvent(localEvent, aGuid, aInputBlockId,
- aApzResponse, status);
+ aApzResponse, status);
return IPC_OK();
}
mozilla::ipc::IPCResult
TabChild::RecvRealTouchMoveEvent(const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
const uint64_t& aInputBlockId,
const nsEventStatus& aApzResponse)
@@ -1777,17 +1783,18 @@ TabChild::RequestNativeKeyBindings(AutoC
aAutoCache->CacheNoCommands();
}
}
mozilla::ipc::IPCResult
TabChild::RecvNativeSynthesisResponse(const uint64_t& aObserverId,
const nsCString& aResponse)
{
- mozilla::widget::AutoObserverNotifier::NotifySavedObserver(aObserverId, aResponse.get());
+ mozilla::widget::AutoObserverNotifier::NotifySavedObserver(aObserverId,
+ aResponse.get());
return IPC_OK();
}
// In case handling repeated keys takes much time, we skip firing new ones.
bool
TabChild::SkipRepeatedKeyEvent(const WidgetKeyboardEvent& aEvent)
{
if (mRepeatedKeyEventTime.IsNull() ||
@@ -1930,17 +1937,18 @@ TabChild::RecvPasteTransferable(const IP
trans, nullptr, this);
NS_ENSURE_SUCCESS(rv, IPC_OK());
nsCOMPtr<nsIDocShell> ourDocShell = do_GetInterface(WebNavigation());
if (NS_WARN_IF(!ourDocShell)) {
return IPC_OK();
}
- nsCOMPtr<nsICommandParams> params = do_CreateInstance("@mozilla.org/embedcomp/command-params;1", &rv);
+ nsCOMPtr<nsICommandParams> params =
+ do_CreateInstance("@mozilla.org/embedcomp/command-params;1", &rv);
NS_ENSURE_SUCCESS(rv, IPC_OK());
rv = params->SetISupportsValue("transferable", trans);
NS_ENSURE_SUCCESS(rv, IPC_OK());
ourDocShell->DoCommandWithParams("cmd_pasteTransferable", params);
return IPC_OK();
}
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -1053,31 +1053,33 @@ TabParent::DeallocPIndexedDBPermissionRe
void
TabParent::SendMouseEvent(const nsAString& aType, float aX, float aY,
int32_t aButton, int32_t aClickCount,
int32_t aModifiers, bool aIgnoreRootScrollFrame)
{
if (!mIsDestroyed) {
Unused << PBrowserParent::SendMouseEvent(nsString(aType), aX, aY,
aButton, aClickCount,
- aModifiers, aIgnoreRootScrollFrame);
+ aModifiers,
+ aIgnoreRootScrollFrame);
}
}
void
TabParent::SendKeyEvent(const nsAString& aType,
int32_t aKeyCode,
int32_t aCharCode,
int32_t aModifiers,
bool aPreventDefault)
{
- if (!mIsDestroyed) {
- Unused << PBrowserParent::SendKeyEvent(nsString(aType), aKeyCode, aCharCode,
- aModifiers, aPreventDefault);
+ if (mIsDestroyed) {
+ return;
}
+ Unused << PBrowserParent::SendKeyEvent(nsString(aType), aKeyCode, aCharCode,
+ aModifiers, aPreventDefault);
}
bool
TabParent::SendRealMouseEvent(WidgetMouseEvent& aEvent)
{
if (mIsDestroyed) {
return false;
}
@@ -1085,17 +1087,18 @@ TabParent::SendRealMouseEvent(WidgetMous
nsCOMPtr<nsIWidget> widget = GetWidget();
if (widget) {
// When we mouseenter the tab, the tab's cursor should
// become the current cursor. When we mouseexit, we stop.
if (eMouseEnterIntoWidget == aEvent.mMessage) {
mTabSetsCursor = true;
if (mCustomCursor) {
- widget->SetCursor(mCustomCursor, mCustomCursorHotspotX, mCustomCursorHotspotY);
+ widget->SetCursor(mCustomCursor,
+ mCustomCursorHotspotX, mCustomCursorHotspotY);
} else if (mCursor != nsCursor(-1)) {
widget->SetCursor(mCursor);
}
} else if (eMouseExitFromWidget == aEvent.mMessage) {
mTabSetsCursor = false;
}
}
@@ -1203,17 +1206,18 @@ TabParent::RecvDispatchKeyboardEvent(con
widget->DispatchInputEvent(&localEvent);
return IPC_OK();
}
static void
DoCommandCallback(mozilla::Command aCommand, void* aData)
{
- static_cast<InfallibleTArray<mozilla::CommandInt>*>(aData)->AppendElement(aCommand);
+ static_cast<InfallibleTArray<mozilla::CommandInt>*>(aData)->
+ AppendElement(aCommand);
}
mozilla::ipc::IPCResult
TabParent::RecvRequestNativeKeyBindings(const WidgetKeyboardEvent& aEvent,
MaybeNativeKeyBinding* aBindings)
{
AutoTArray<mozilla::CommandInt, 4> singleLine;
AutoTArray<mozilla::CommandInt, 4> multiLine;
@@ -1227,22 +1231,25 @@ TabParent::RecvRequestNativeKeyBindings(
}
WidgetKeyboardEvent localEvent(aEvent);
if (NS_FAILED(widget->AttachNativeKeyEvent(localEvent))) {
return IPC_OK();
}
- widget->ExecuteNativeKeyBinding(nsIWidget::NativeKeyBindingsForSingleLineEditor,
- localEvent, DoCommandCallback, &singleLine);
- widget->ExecuteNativeKeyBinding(nsIWidget::NativeKeyBindingsForMultiLineEditor,
- localEvent, DoCommandCallback, &multiLine);
- widget->ExecuteNativeKeyBinding(nsIWidget::NativeKeyBindingsForRichTextEditor,
- localEvent, DoCommandCallback, &richText);
+ widget->ExecuteNativeKeyBinding(
+ nsIWidget::NativeKeyBindingsForSingleLineEditor,
+ localEvent, DoCommandCallback, &singleLine);
+ widget->ExecuteNativeKeyBinding(
+ nsIWidget::NativeKeyBindingsForMultiLineEditor,
+ localEvent, DoCommandCallback, &multiLine);
+ widget->ExecuteNativeKeyBinding(
+ nsIWidget::NativeKeyBindingsForRichTextEditor,
+ localEvent, DoCommandCallback, &richText);
if (!singleLine.IsEmpty() || !multiLine.IsEmpty() || !richText.IsEmpty()) {
*aBindings = NativeKeyBinding(singleLine, multiLine, richText);
}
return IPC_OK();
}
@@ -1263,17 +1270,18 @@ public:
const char16_t* aData) override
{
if (!mTabParent || !mObserverId) {
// We already sent the notification, or we don't actually need to
// send any notification at all.
return NS_OK;
}
- if (!mTabParent->SendNativeSynthesisResponse(mObserverId, nsCString(aTopic))) {
+ if (!mTabParent->SendNativeSynthesisResponse(mObserverId,
+ nsCString(aTopic))) {
NS_WARNING("Unable to send native event synthesization response!");
}
// Null out tabparent to indicate we already sent the response
mTabParent = nullptr;
return NS_OK;
}
private:
@@ -1318,33 +1326,34 @@ TabParent::RecvSynthesizeNativeKeyEvent(
const nsString& aCharacters,
const nsString& aUnmodifiedCharacters,
const uint64_t& aObserverId)
{
AutoSynthesizedEventResponder responder(this, aObserverId, "keyevent");
nsCOMPtr<nsIWidget> widget = GetWidget();
if (widget) {
widget->SynthesizeNativeKeyEvent(aNativeKeyboardLayout, aNativeKeyCode,
- aModifierFlags, aCharacters, aUnmodifiedCharacters,
- responder.GetObserver());
+ aModifierFlags, aCharacters,
+ aUnmodifiedCharacters,
+ responder.GetObserver());
}
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvSynthesizeNativeMouseEvent(const LayoutDeviceIntPoint& aPoint,
const uint32_t& aNativeMessage,
const uint32_t& aModifierFlags,
const uint64_t& aObserverId)
{
AutoSynthesizedEventResponder responder(this, aObserverId, "mouseevent");
nsCOMPtr<nsIWidget> widget = GetWidget();
if (widget) {
widget->SynthesizeNativeMouseEvent(aPoint, aNativeMessage, aModifierFlags,
- responder.GetObserver());
+ responder.GetObserver());
}
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvSynthesizeNativeMouseMove(const LayoutDeviceIntPoint& aPoint,
const uint64_t& aObserverId)
{
@@ -1352,48 +1361,52 @@ TabParent::RecvSynthesizeNativeMouseMove
nsCOMPtr<nsIWidget> widget = GetWidget();
if (widget) {
widget->SynthesizeNativeMouseMove(aPoint, responder.GetObserver());
}
return IPC_OK();
}
mozilla::ipc::IPCResult
-TabParent::RecvSynthesizeNativeMouseScrollEvent(const LayoutDeviceIntPoint& aPoint,
- const uint32_t& aNativeMessage,
- const double& aDeltaX,
- const double& aDeltaY,
- const double& aDeltaZ,
- const uint32_t& aModifierFlags,
- const uint32_t& aAdditionalFlags,
- const uint64_t& aObserverId)
+TabParent::RecvSynthesizeNativeMouseScrollEvent(
+ const LayoutDeviceIntPoint& aPoint,
+ const uint32_t& aNativeMessage,
+ const double& aDeltaX,
+ const double& aDeltaY,
+ const double& aDeltaZ,
+ const uint32_t& aModifierFlags,
+ const uint32_t& aAdditionalFlags,
+ const uint64_t& aObserverId)
{
AutoSynthesizedEventResponder responder(this, aObserverId, "mousescrollevent");
nsCOMPtr<nsIWidget> widget = GetWidget();
if (widget) {
widget->SynthesizeNativeMouseScrollEvent(aPoint, aNativeMessage,
- aDeltaX, aDeltaY, aDeltaZ, aModifierFlags, aAdditionalFlags,
- responder.GetObserver());
+ aDeltaX, aDeltaY, aDeltaZ,
+ aModifierFlags, aAdditionalFlags,
+ responder.GetObserver());
}
return IPC_OK();
}
mozilla::ipc::IPCResult
-TabParent::RecvSynthesizeNativeTouchPoint(const uint32_t& aPointerId,
- const TouchPointerState& aPointerState,
- const LayoutDeviceIntPoint& aPoint,
- const double& aPointerPressure,
- const uint32_t& aPointerOrientation,
- const uint64_t& aObserverId)
+TabParent::RecvSynthesizeNativeTouchPoint(
+ const uint32_t& aPointerId,
+ const TouchPointerState& aPointerState,
+ const LayoutDeviceIntPoint& aPoint,
+ const double& aPointerPressure,
+ const uint32_t& aPointerOrientation,
+ const uint64_t& aObserverId)
{
AutoSynthesizedEventResponder responder(this, aObserverId, "touchpoint");
nsCOMPtr<nsIWidget> widget = GetWidget();
if (widget) {
widget->SynthesizeNativeTouchPoint(aPointerId, aPointerState, aPoint,
- aPointerPressure, aPointerOrientation, responder.GetObserver());
+ aPointerPressure, aPointerOrientation,
+ responder.GetObserver());
}
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvSynthesizeNativeTouchTap(const LayoutDeviceIntPoint& aPoint,
const bool& aLongTap,
const uint64_t& aObserverId)
@@ -1500,18 +1513,18 @@ TabParent::SendHandleTap(TapType aType,
if (mIsDestroyed) {
return false;
}
if ((aType == TapType::eSingleTap || aType == TapType::eSecondTap) &&
GetRenderFrame()) {
GetRenderFrame()->TakeFocusForClickFromTap();
}
LayoutDeviceIntPoint offset = GetChildProcessOffset();
- return PBrowserParent::SendHandleTap(aType, aPoint + offset, aModifiers, aGuid,
- aInputBlockId);
+ return PBrowserParent::SendHandleTap(aType, aPoint + offset, aModifiers,
+ aGuid, aInputBlockId);
}
mozilla::ipc::IPCResult
TabParent::RecvSyncMessage(const nsString& aMessage,
const ClonedMessageData& aData,
InfallibleTArray<CpowEntry>&& aCpows,
const IPC::Principal& aPrincipal,
nsTArray<StructuredCloneData>* aRetVal)
@@ -1708,53 +1721,53 @@ TabParent::RecvNotifyIMEFocus(const Cont
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvNotifyIMETextChange(const ContentCache& aContentCache,
const IMENotification& aIMENotification)
{
nsCOMPtr<nsIWidget> widget = GetWidget();
- if (!widget)
+ if (!widget) {
return IPC_OK();
+ }
#ifdef DEBUG
nsIMEUpdatePreference updatePreference = widget->GetIMEUpdatePreference();
NS_ASSERTION(updatePreference.WantTextChange(),
- "Don't call Send/RecvNotifyIMETextChange without NOTIFY_TEXT_CHANGE");
+ "Don't call Send/RecvNotifyIMETextChange without NOTIFY_TEXT_CHANGE");
#endif
mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
mContentCache.MaybeNotifyIME(widget, aIMENotification);
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvNotifyIMECompositionUpdate(
const ContentCache& aContentCache,
const IMENotification& aIMENotification)
{
nsCOMPtr<nsIWidget> widget = GetWidget();
if (!widget) {
return IPC_OK();
}
-
mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
mContentCache.MaybeNotifyIME(widget, aIMENotification);
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvNotifyIMESelection(const ContentCache& aContentCache,
const IMENotification& aIMENotification)
{
nsCOMPtr<nsIWidget> widget = GetWidget();
- if (!widget)
+ if (!widget) {
return IPC_OK();
-
+ }
mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
mContentCache.MaybeNotifyIME(widget, aIMENotification);
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvUpdateContentCache(const ContentCache& aContentCache)
{
@@ -1786,17 +1799,16 @@ TabParent::RecvNotifyIMEMouseButtonEvent
mozilla::ipc::IPCResult
TabParent::RecvNotifyIMEPositionChange(const ContentCache& aContentCache,
const IMENotification& aIMENotification)
{
nsCOMPtr<nsIWidget> widget = GetWidget();
if (!widget) {
return IPC_OK();
}
-
mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
mContentCache.MaybeNotifyIME(widget, aIMENotification);
return IPC_OK();
}
mozilla::ipc::IPCResult
TabParent::RecvOnEventNeedingAckHandled(const EventMessage& aMessage)
{
--- a/widget/PuppetWidget.cpp
+++ b/widget/PuppetWidget.cpp
@@ -405,114 +405,121 @@ PuppetWidget::SynthesizeNativeKeyEvent(i
const nsAString& aUnmodifiedCharacters,
nsIObserver* aObserver)
{
AutoObserverNotifier notifier(aObserver, "keyevent");
if (!mTabChild) {
return NS_ERROR_FAILURE;
}
mTabChild->SendSynthesizeNativeKeyEvent(aNativeKeyboardLayout, aNativeKeyCode,
- aModifierFlags, nsString(aCharacters), nsString(aUnmodifiedCharacters),
- notifier.SaveObserver());
+ aModifierFlags, nsString(aCharacters),
+ nsString(aUnmodifiedCharacters),
+ notifier.SaveObserver());
return NS_OK;
}
nsresult
PuppetWidget::SynthesizeNativeMouseEvent(mozilla::LayoutDeviceIntPoint aPoint,
uint32_t aNativeMessage,
uint32_t aModifierFlags,
nsIObserver* aObserver)
{
AutoObserverNotifier notifier(aObserver, "mouseevent");
if (!mTabChild) {
return NS_ERROR_FAILURE;
}
mTabChild->SendSynthesizeNativeMouseEvent(aPoint, aNativeMessage,
- aModifierFlags, notifier.SaveObserver());
+ aModifierFlags,
+ notifier.SaveObserver());
return NS_OK;
}
nsresult
PuppetWidget::SynthesizeNativeMouseMove(mozilla::LayoutDeviceIntPoint aPoint,
nsIObserver* aObserver)
{
AutoObserverNotifier notifier(aObserver, "mousemove");
if (!mTabChild) {
return NS_ERROR_FAILURE;
}
mTabChild->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)
+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 (!mTabChild) {
return NS_ERROR_FAILURE;
}
mTabChild->SendSynthesizeNativeMouseScrollEvent(aPoint, aNativeMessage,
- aDeltaX, aDeltaY, aDeltaZ, aModifierFlags, aAdditionalFlags,
- notifier.SaveObserver());
+ 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 (!mTabChild) {
return NS_ERROR_FAILURE;
}
mTabChild->SendSynthesizeNativeTouchPoint(aPointerId, aPointerState,
- aPoint, aPointerPressure, aPointerOrientation,
- notifier.SaveObserver());
+ aPoint, aPointerPressure,
+ aPointerOrientation,
+ notifier.SaveObserver());
return NS_OK;
}
nsresult
PuppetWidget::SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint,
bool aLongTap,
nsIObserver* aObserver)
{
AutoObserverNotifier notifier(aObserver, "touchtap");
if (!mTabChild) {
return NS_ERROR_FAILURE;
}
mTabChild->SendSynthesizeNativeTouchTap(aPoint, aLongTap,
- notifier.SaveObserver());
+ notifier.SaveObserver());
return NS_OK;
}
nsresult
PuppetWidget::ClearNativeTouchSequence(nsIObserver* aObserver)
{
AutoObserverNotifier notifier(aObserver, "cleartouch");
if (!mTabChild) {
return NS_ERROR_FAILURE;
}
mTabChild->SendClearNativeTouchSequence(notifier.SaveObserver());
return NS_OK;
}
void
-PuppetWidget::SetConfirmedTargetAPZC(uint64_t aInputBlockId,
- const nsTArray<ScrollableLayerGuid>& aTargets) const
+PuppetWidget::SetConfirmedTargetAPZC(
+ uint64_t aInputBlockId,
+ const nsTArray<ScrollableLayerGuid>& aTargets) const
{
if (mTabChild) {
mTabChild->SetTargetAPZC(aInputBlockId, aTargets);
}
}
void
PuppetWidget::UpdateZoomConstraints(const uint32_t& aPresShellId,
@@ -526,25 +533,22 @@ PuppetWidget::UpdateZoomConstraints(cons
bool
PuppetWidget::AsyncPanZoomEnabled() const
{
return mTabChild && mTabChild->AsyncPanZoomEnabled();
}
bool
-PuppetWidget::ExecuteNativeKeyBinding(NativeKeyBindingsType aType,
- const mozilla::WidgetKeyboardEvent& aEvent,
- DoCommandCallback aCallback,
- void* aCallbackData)
+PuppetWidget::ExecuteNativeKeyBinding(
+ NativeKeyBindingsType aType,
+ const mozilla::WidgetKeyboardEvent& aEvent,
+ DoCommandCallback aCallback,
+ void* aCallbackData)
{
- // B2G doesn't have native key bindings.
-#ifdef MOZ_WIDGET_GONK
- return false;
-#else // #ifdef MOZ_WIDGET_GONK
AutoCacheNativeKeyCommands autoCache(this);
if (!aEvent.mWidget && !mNativeKeyCommandsValid) {
MOZ_ASSERT(!aEvent.mFlags.mIsSynthesizedForTests);
// Abort if untrusted to avoid leaking system settings
if (NS_WARN_IF(!aEvent.IsTrusted())) {
return false;
}
mTabChild->RequestNativeKeyBindings(&autoCache, &aEvent);
@@ -571,17 +575,16 @@ PuppetWidget::ExecuteNativeKeyBinding(Na
if (commands->IsEmpty()) {
return false;
}
for (uint32_t i = 0; i < commands->Length(); i++) {
aCallback(static_cast<mozilla::Command>((*commands)[i]), aCallbackData);
}
return true;
-#endif
}
LayerManager*
PuppetWidget::GetLayerManager(PLayerTransactionChild* aShadowManager,
LayersBackend aBackendHint,
LayerManagerPersistence aPersistence)
{
if (!mLayerManager) {
@@ -602,17 +605,16 @@ PuppetWidget::RecreateLayerManager(PLaye
lf->SetShadowManager(aShadowManager);
}
return mLayerManager;
}
nsresult
PuppetWidget::RequestIMEToCommitComposition(bool aCancel)
{
-#ifdef MOZ_CROSS_PROCESS_IME
if (!mTabChild) {
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())) {
@@ -642,19 +644,16 @@ PuppetWidget::RequestIMEToCommitComposit
// Dispatch eCompositionCommit event.
WidgetCompositionEvent compositionCommitEvent(true, eCompositionCommit, this);
InitEvent(compositionCommitEvent, nullptr);
compositionCommitEvent.mData = committedString;
nsEventStatus status = nsEventStatus_eIgnore;
DispatchEvent(&compositionCommitEvent, status);
// NOTE: PuppetWidget might be destroyed already.
-
-#endif // #ifdef MOZ_CROSS_PROCESS_IME
-
return NS_OK;
}
nsresult
PuppetWidget::NotifyIMEInternal(const IMENotification& aIMENotification)
{
switch (aIMENotification.mMessage) {
case REQUEST_TO_COMMIT_COMPOSITION:
@@ -713,41 +712,32 @@ 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;
-
-#ifndef MOZ_CROSS_PROCESS_IME
- return;
-#endif
-
if (!mTabChild) {
return;
}
mTabChild->SendSetInputContext(
static_cast<int32_t>(aContext.mIMEState.mEnabled),
static_cast<int32_t>(aContext.mIMEState.mOpen),
aContext.mHTMLInputType,
aContext.mHTMLInputInputmode,
aContext.mActionHint,
static_cast<int32_t>(aAction.mCause),
static_cast<int32_t>(aAction.mFocusChange));
}
InputContext
PuppetWidget::GetInputContext()
{
-#ifndef MOZ_CROSS_PROCESS_IME
- return InputContext();
-#endif
-
// XXX Currently, we don't support retrieving IME open state from child
// process.
// When this widget caches input context and currently managed by
// IMEStateManager, the cache is valid. Only in this case, we can
// avoid to use synchronous IPC.
if (mInputContext.mIMEState.mEnabled != IMEState::UNKNOWN &&
IMEStateManager::GetWidgetForActiveInputContext() == this) {
@@ -773,22 +763,19 @@ NativeIMEContext
PuppetWidget::GetNativeIMEContext()
{
return mNativeIMEContext;
}
nsresult
PuppetWidget::NotifyIMEOfFocusChange(const IMENotification& aIMENotification)
{
-#ifndef MOZ_CROSS_PROCESS_IME
- return NS_OK;
-#endif
-
- if (!mTabChild)
+ if (!mTabChild) {
return NS_ERROR_FAILURE;
+ }
bool gotFocus = aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS;
if (gotFocus) {
if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN) {
// When IME gets focus, we should initalize all information of the
// content.
if (NS_WARN_IF(!mContentCache.CacheAll(this, &aIMENotification))) {
return NS_ERROR_FAILURE;
@@ -812,66 +799,55 @@ PuppetWidget::NotifyIMEOfFocusChange(con
}
return NS_OK;
}
nsresult
PuppetWidget::NotifyIMEOfCompositionUpdate(
const IMENotification& aIMENotification)
{
-#ifndef MOZ_CROSS_PROCESS_IME
- return NS_OK;
-#endif
-
- NS_ENSURE_TRUE(mTabChild, NS_ERROR_FAILURE);
+ if (NS_WARN_IF(!mTabChild)) {
+ return NS_ERROR_FAILURE;
+ }
if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN &&
NS_WARN_IF(!mContentCache.CacheSelection(this, &aIMENotification))) {
return NS_ERROR_FAILURE;
}
mTabChild->SendNotifyIMECompositionUpdate(mContentCache, aIMENotification);
return NS_OK;
}
nsIMEUpdatePreference
PuppetWidget::GetIMEUpdatePreference()
{
-#ifdef MOZ_CROSS_PROCESS_IME
// e10s requires IME content cache in in the TabParent for handling query
// content event only with the parent process. Therefore, this process
// needs to receive a lot of information from the focused editor to sent
// the latest content to the parent process.
if (mInputContext.mIMEState.mEnabled == IMEState::PLUGIN) {
// But if a plugin has focus, we cannot receive text nor selection change
// in the plugin. Therefore, PuppetWidget needs to receive only position
// change event for updating the editor rect cache.
return nsIMEUpdatePreference(mIMEPreferenceOfParent.mWantUpdates |
nsIMEUpdatePreference::NOTIFY_POSITION_CHANGE);
}
return nsIMEUpdatePreference(mIMEPreferenceOfParent.mWantUpdates |
nsIMEUpdatePreference::NOTIFY_TEXT_CHANGE |
nsIMEUpdatePreference::NOTIFY_POSITION_CHANGE );
-#else
- // B2G doesn't handle IME as widget-level.
- return nsIMEUpdatePreference();
-#endif
}
nsresult
PuppetWidget::NotifyIMEOfTextChange(const IMENotification& aIMENotification)
{
MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_TEXT_CHANGE,
"Passed wrong notification");
-
-#ifndef MOZ_CROSS_PROCESS_IME
- return NS_OK;
-#endif
-
- if (!mTabChild)
+ if (!mTabChild) {
return NS_ERROR_FAILURE;
+ }
// While a plugin has focus, text change notification shouldn't be available.
if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
return NS_ERROR_FAILURE;
}
// FYI: text change notification is the first notification after
// a user operation changes the content. So, we need to modify
@@ -892,23 +868,19 @@ PuppetWidget::NotifyIMEOfTextChange(cons
}
nsresult
PuppetWidget::NotifyIMEOfSelectionChange(
const IMENotification& aIMENotification)
{
MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_SELECTION_CHANGE,
"Passed wrong notification");
-
-#ifndef MOZ_CROSS_PROCESS_IME
- return NS_OK;
-#endif
-
- if (!mTabChild)
+ if (!mTabChild) {
return NS_ERROR_FAILURE;
+ }
// While a plugin has focus, selection change notification shouldn't be
// available.
if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
return NS_ERROR_FAILURE;
}
// Note that selection change must be notified after text change if it occurs.
@@ -947,19 +919,16 @@ PuppetWidget::NotifyIMEOfMouseButtonEven
}
return consumedByIME ? NS_SUCCESS_EVENT_CONSUMED : NS_OK;
}
nsresult
PuppetWidget::NotifyIMEOfPositionChange(const IMENotification& aIMENotification)
{
-#ifndef MOZ_CROSS_PROCESS_IME
- return NS_OK;
-#endif
if (NS_WARN_IF(!mTabChild)) {
return NS_ERROR_FAILURE;
}
if (NS_WARN_IF(!mContentCache.CacheEditorRect(this, &aIMENotification))) {
return NS_ERROR_FAILURE;
}
// While a plugin has focus, selection range isn't available. So, we don't