Add m-esr52 at 52.6.0

1 files changed, 6002 insertions, 0 deletions

diff --git a/dom/events/EventStateManager.cpp b/dom/events/EventStateManager.cpp
new file mode 100644
index 000000000..659629066
--- /dev/null
+++ b/dom/events/EventStateManager.cpp
@@ -0,0 +1,6002 @@
+/* -*- 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/Attributes.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/IMEStateManager.h"
+#include "mozilla/MiscEvents.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TextComposition.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/DragEvent.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/UIEvent.h"
+
+#include "ContentEventHandler.h"
+#include "IMEContentObserver.h"
+#include "WheelHandlingHelper.h"
+
+#include "nsCOMPtr.h"
+#include "nsFocusManager.h"
+#include "nsIContent.h"
+#include "nsIContentInlines.h"
+#include "nsIDocument.h"
+#include "nsIFrame.h"
+#include "nsIWidget.h"
+#include "nsPresContext.h"
+#include "nsIPresShell.h"
+#include "nsGkAtoms.h"
+#include "nsIFormControl.h"
+#include "nsIComboboxControlFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsIDOMXULControlElement.h"
+#include "nsNameSpaceManager.h"
+#include "nsIBaseWindow.h"
+#include "nsISelection.h"
+#include "nsITextControlElement.h"
+#include "nsFrameSelection.h"
+#include "nsPIDOMWindow.h"
+#include "nsPIWindowRoot.h"
+#include "nsIWebNavigation.h"
+#include "nsIContentViewer.h"
+#include "nsFrameManager.h"
+#include "nsITabChild.h"
+#include "nsPluginFrame.h"
+#include "nsMenuPopupFrame.h"
+
+#include "nsIDOMXULElement.h"
+#include "nsIDOMKeyEvent.h"
+#include "nsIObserverService.h"
+#include "nsIDocShell.h"
+#include "nsIDOMWheelEvent.h"
+#include "nsIDOMUIEvent.h"
+#include "nsIMozBrowserFrame.h"
+
+#include "nsSubDocumentFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsUnicharUtils.h"
+#include "nsContentUtils.h"
+
+#include "imgIContainer.h"
+#include "nsIProperties.h"
+#include "nsISupportsPrimitives.h"
+
+#include "nsServiceManagerUtils.h"
+#include "nsITimer.h"
+#include "nsFontMetrics.h"
+#include "nsIDOMXULDocument.h"
+#include "nsIDragService.h"
+#include "nsIDragSession.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "nsContentAreaDragDrop.h"
+#ifdef MOZ_XUL
+#include "nsTreeBodyFrame.h"
+#endif
+#include "nsIController.h"
+#include "nsICommandParams.h"
+#include "mozilla/Services.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/HTMLLabelElement.h"
+
+#include "mozilla/Preferences.h"
+#include "mozilla/LookAndFeel.h"
+#include "GeckoProfiler.h"
+#include "Units.h"
+#include "mozilla/layers/APZCTreeManager.h"
+
+#ifdef XP_MACOSX
+#import <ApplicationServices/ApplicationServices.h>
+#endif
+
+namespace mozilla {
+
+using namespace dom;
+
+//#define DEBUG_DOCSHELL_FOCUS
+
+#define NS_USER_INTERACTION_INTERVAL 5000 // ms
+
+static const LayoutDeviceIntPoint kInvalidRefPoint = LayoutDeviceIntPoint(-1,-1);
+
+static uint32_t gMouseOrKeyboardEventCounter = 0;
+static nsITimer* gUserInteractionTimer = nullptr;
+static nsITimerCallback* gUserInteractionTimerCallback = nullptr;
+
+static const double kCursorLoadingTimeout = 1000; // ms
+static nsWeakFrame gLastCursorSourceFrame;
+static TimeStamp gLastCursorUpdateTime;
+
+static inline int32_t
+RoundDown(double aDouble)
+{
+  return (aDouble > 0) ? static_cast<int32_t>(floor(aDouble)) :
+                         static_cast<int32_t>(ceil(aDouble));
+}
+
+#ifdef DEBUG_DOCSHELL_FOCUS
+static void
+PrintDocTree(nsIDocShellTreeItem* aParentItem, int aLevel)
+{
+  for (int32_t i=0;i<aLevel;i++) printf("  ");
+
+  int32_t childWebshellCount;
+  aParentItem->GetChildCount(&childWebshellCount);
+  nsCOMPtr<nsIDocShell> parentAsDocShell(do_QueryInterface(aParentItem));
+  int32_t type = aParentItem->ItemType();
+  nsCOMPtr<nsIPresShell> presShell = parentAsDocShell->GetPresShell();
+  RefPtr<nsPresContext> presContext;
+  parentAsDocShell->GetPresContext(getter_AddRefs(presContext));
+  nsCOMPtr<nsIContentViewer> cv;
+  parentAsDocShell->GetContentViewer(getter_AddRefs(cv));
+  nsCOMPtr<nsIDOMDocument> domDoc;
+  if (cv)
+    cv->GetDOMDocument(getter_AddRefs(domDoc));
+  nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
+  nsCOMPtr<nsIDOMWindow> domwin = doc ? doc->GetWindow() : nullptr;
+  nsIURI* uri = doc ? doc->GetDocumentURI() : nullptr;
+
+  printf("DS %p  Type %s  Cnt %d  Doc %p  DW %p  EM %p%c",
+    static_cast<void*>(parentAsDocShell.get()),
+    type==nsIDocShellTreeItem::typeChrome?"Chrome":"Content",
+    childWebshellCount, static_cast<void*>(doc.get()),
+    static_cast<void*>(domwin.get()),
+    static_cast<void*>(presContext ? presContext->EventStateManager() : nullptr),
+    uri ? ' ' : '\n');
+  if (uri) {
+    nsAutoCString spec;
+    uri->GetSpec(spec);
+    printf("\"%s\"\n", spec.get());
+  }
+
+  if (childWebshellCount > 0) {
+    for (int32_t i = 0; i < childWebshellCount; i++) {
+      nsCOMPtr<nsIDocShellTreeItem> child;
+      aParentItem->GetChildAt(i, getter_AddRefs(child));
+      PrintDocTree(child, aLevel + 1);
+    }
+  }
+}
+
+static void
+PrintDocTreeAll(nsIDocShellTreeItem* aItem)
+{
+  nsCOMPtr<nsIDocShellTreeItem> item = aItem;
+  for(;;) {
+    nsCOMPtr<nsIDocShellTreeItem> parent;
+    item->GetParent(getter_AddRefs(parent));
+    if (!parent)
+      break;
+    item = parent;
+  }
+
+  PrintDocTree(item, 0);
+}
+#endif
+
+// mask values for ui.key.chromeAccess and ui.key.contentAccess
+#define NS_MODIFIER_SHIFT    1
+#define NS_MODIFIER_CONTROL  2
+#define NS_MODIFIER_ALT      4
+#define NS_MODIFIER_META     8
+#define NS_MODIFIER_OS       16
+
+/******************************************************************/
+/* mozilla::UITimerCallback                                       */
+/******************************************************************/
+
+class UITimerCallback final : public nsITimerCallback
+{
+public:
+  UITimerCallback() : mPreviousCount(0) {}
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITIMERCALLBACK
+private:
+  ~UITimerCallback() {}
+  uint32_t mPreviousCount;
+};
+
+NS_IMPL_ISUPPORTS(UITimerCallback, nsITimerCallback)
+
+// If aTimer is nullptr, this method always sends "user-interaction-inactive"
+// notification.
+NS_IMETHODIMP
+UITimerCallback::Notify(nsITimer* aTimer)
+{
+  nsCOMPtr<nsIObserverService> obs =
+    mozilla::services::GetObserverService();
+  if (!obs)
+    return NS_ERROR_FAILURE;
+  if ((gMouseOrKeyboardEventCounter == mPreviousCount) || !aTimer) {
+    gMouseOrKeyboardEventCounter = 0;
+    obs->NotifyObservers(nullptr, "user-interaction-inactive", nullptr);
+    if (gUserInteractionTimer) {
+      gUserInteractionTimer->Cancel();
+      NS_RELEASE(gUserInteractionTimer);
+    }
+  } else {
+    obs->NotifyObservers(nullptr, "user-interaction-active", nullptr);
+    EventStateManager::UpdateUserActivityTimer();
+  }
+  mPreviousCount = gMouseOrKeyboardEventCounter;
+  return NS_OK;
+}
+
+/******************************************************************/
+/* mozilla::OverOutElementsWrapper                                */
+/******************************************************************/
+
+OverOutElementsWrapper::OverOutElementsWrapper()
+  : mLastOverFrame(nullptr)
+{
+}
+
+OverOutElementsWrapper::~OverOutElementsWrapper()
+{
+}
+
+NS_IMPL_CYCLE_COLLECTION(OverOutElementsWrapper,
+                         mLastOverElement,
+                         mFirstOverEventElement,
+                         mFirstOutEventElement)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(OverOutElementsWrapper)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(OverOutElementsWrapper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(OverOutElementsWrapper)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+/******************************************************************/
+/* mozilla::EventStateManager                                     */
+/******************************************************************/
+
+static uint32_t sESMInstanceCount = 0;
+static bool sPointerEventEnabled = false;
+
+uint64_t EventStateManager::sUserInputCounter = 0;
+int32_t EventStateManager::sUserInputEventDepth = 0;
+bool EventStateManager::sNormalLMouseEventInProcess = false;
+EventStateManager* EventStateManager::sActiveESM = nullptr;
+nsIDocument* EventStateManager::sMouseOverDocument = nullptr;
+nsWeakFrame EventStateManager::sLastDragOverFrame = nullptr;
+LayoutDeviceIntPoint EventStateManager::sPreLockPoint = LayoutDeviceIntPoint(0, 0);
+LayoutDeviceIntPoint EventStateManager::sLastRefPoint = kInvalidRefPoint;
+CSSIntPoint EventStateManager::sLastScreenPoint = CSSIntPoint(0, 0);
+LayoutDeviceIntPoint EventStateManager::sSynthCenteringPoint = kInvalidRefPoint;
+CSSIntPoint EventStateManager::sLastClientPoint = CSSIntPoint(0, 0);
+bool EventStateManager::sIsPointerLocked = false;
+// Reference to the pointer locked element.
+nsWeakPtr EventStateManager::sPointerLockedElement;
+// Reference to the document which requested pointer lock.
+nsWeakPtr EventStateManager::sPointerLockedDoc;
+nsCOMPtr<nsIContent> EventStateManager::sDragOverContent = nullptr;
+TimeStamp EventStateManager::sLatestUserInputStart;
+TimeStamp EventStateManager::sHandlingInputStart;
+
+EventStateManager::WheelPrefs*
+  EventStateManager::WheelPrefs::sInstance = nullptr;
+bool EventStateManager::WheelPrefs::sWheelEventsEnabledOnPlugins = true;
+EventStateManager::DeltaAccumulator*
+  EventStateManager::DeltaAccumulator::sInstance = nullptr;
+
+EventStateManager::EventStateManager()
+  : mLockCursor(0)
+  , mLastFrameConsumedSetCursor(false)
+  , mCurrentTarget(nullptr)
+    // init d&d gesture state machine variables
+  , mGestureDownPoint(0,0)
+  , mPresContext(nullptr)
+  , mLClickCount(0)
+  , mMClickCount(0)
+  , mRClickCount(0)
+  , mInTouchDrag(false)
+  , m_haveShutdown(false)
+{
+  if (sESMInstanceCount == 0) {
+    gUserInteractionTimerCallback = new UITimerCallback();
+    if (gUserInteractionTimerCallback)
+      NS_ADDREF(gUserInteractionTimerCallback);
+    UpdateUserActivityTimer();
+  }
+  ++sESMInstanceCount;
+
+  static bool sAddedPointerEventEnabled = false;
+  if (!sAddedPointerEventEnabled) {
+    Preferences::AddBoolVarCache(&sPointerEventEnabled,
+                                 "dom.w3c_pointer_events.enabled", false);
+    sAddedPointerEventEnabled = true;
+  }
+}
+
+nsresult
+EventStateManager::UpdateUserActivityTimer()
+{
+  if (!gUserInteractionTimerCallback)
+    return NS_OK;
+
+  if (!gUserInteractionTimer)
+    CallCreateInstance("@mozilla.org/timer;1", &gUserInteractionTimer);
+
+  if (gUserInteractionTimer) {
+    gUserInteractionTimer->InitWithCallback(gUserInteractionTimerCallback,
+                                            NS_USER_INTERACTION_INTERVAL,
+                                            nsITimer::TYPE_ONE_SHOT);
+  }
+  return NS_OK;
+}
+
+nsresult
+EventStateManager::Init()
+{
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  if (!observerService)
+    return NS_ERROR_FAILURE;
+
+  observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
+
+  if (sESMInstanceCount == 1) {
+    Prefs::Init();
+  }
+
+  return NS_OK;
+}
+
+EventStateManager::~EventStateManager()
+{
+  ReleaseCurrentIMEContentObserver();
+
+  if (sActiveESM == this) {
+    sActiveESM = nullptr;
+  }
+  if (Prefs::ClickHoldContextMenu())
+    KillClickHoldTimer();
+
+  if (mDocument == sMouseOverDocument)
+    sMouseOverDocument = nullptr;
+
+  --sESMInstanceCount;
+  if(sESMInstanceCount == 0) {
+    WheelTransaction::Shutdown();
+    if (gUserInteractionTimerCallback) {
+      gUserInteractionTimerCallback->Notify(nullptr);
+      NS_RELEASE(gUserInteractionTimerCallback);
+    }
+    if (gUserInteractionTimer) {
+      gUserInteractionTimer->Cancel();
+      NS_RELEASE(gUserInteractionTimer);
+    }
+    Prefs::Shutdown();
+    WheelPrefs::Shutdown();
+    DeltaAccumulator::Shutdown();
+  }
+
+  if (sDragOverContent && sDragOverContent->OwnerDoc() == mDocument) {
+    sDragOverContent = nullptr;
+  }
+
+  if (!m_haveShutdown) {
+    Shutdown();
+
+    // Don't remove from Observer service in Shutdown because Shutdown also
+    // gets called from xpcom shutdown observer.  And we don't want to remove
+    // from the service in that case.
+
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    if (observerService) {
+      observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+    }
+  }
+
+}
+
+nsresult
+EventStateManager::Shutdown()
+{
+  m_haveShutdown = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+EventStateManager::Observe(nsISupports* aSubject,
+                           const char* aTopic,
+                           const char16_t *someData)
+{
+  if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+    Shutdown();
+  }
+
+  return NS_OK;
+}
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(EventStateManager)
+   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
+   NS_INTERFACE_MAP_ENTRY(nsIObserver)
+   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(EventStateManager)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(EventStateManager)
+
+NS_IMPL_CYCLE_COLLECTION(EventStateManager,
+                         mCurrentTargetContent,
+                         mGestureDownContent,
+                         mGestureDownFrameOwner,
+                         mLastLeftMouseDownContent,
+                         mLastLeftMouseDownContentParent,
+                         mLastMiddleMouseDownContent,
+                         mLastMiddleMouseDownContentParent,
+                         mLastRightMouseDownContent,
+                         mLastRightMouseDownContentParent,
+                         mActiveContent,
+                         mHoverContent,
+                         mURLTargetContent,
+                         mMouseEnterLeaveHelper,
+                         mPointersEnterLeaveHelper,
+                         mDocument,
+                         mIMEContentObserver,
+                         mAccessKeys)
+
+void
+EventStateManager::ReleaseCurrentIMEContentObserver()
+{
+  if (mIMEContentObserver) {
+    mIMEContentObserver->DisconnectFromEventStateManager();
+  }
+  mIMEContentObserver = nullptr;
+}
+
+void
+EventStateManager::OnStartToObserveContent(
+                     IMEContentObserver* aIMEContentObserver)
+{
+  if (mIMEContentObserver == aIMEContentObserver) {
+    return;
+  }
+  ReleaseCurrentIMEContentObserver();
+  mIMEContentObserver = aIMEContentObserver;
+}
+
+void
+EventStateManager::OnStopObservingContent(
+                     IMEContentObserver* aIMEContentObserver)
+{
+  aIMEContentObserver->DisconnectFromEventStateManager();
+  NS_ENSURE_TRUE_VOID(mIMEContentObserver == aIMEContentObserver);
+  mIMEContentObserver = nullptr;
+}
+
+void
+EventStateManager::TryToFlushPendingNotificationsToIME()
+{
+  if (mIMEContentObserver) {
+    mIMEContentObserver->TryToFlushPendingNotifications();
+  }
+}
+
+static bool
+IsMessageMouseUserActivity(EventMessage aMessage)
+{
+  return aMessage == eMouseMove ||
+         aMessage == eMouseUp ||
+         aMessage == eMouseDown ||
+         aMessage == eMouseDoubleClick ||
+         aMessage == eMouseClick ||
+         aMessage == eMouseActivate ||
+         aMessage == eMouseLongTap;
+}
+
+static bool
+IsMessageGamepadUserActivity(EventMessage aMessage)
+{
+#ifndef MOZ_GAMEPAD
+  return false;
+#else
+  return aMessage == eGamepadButtonDown ||
+         aMessage == eGamepadButtonUp ||
+         aMessage == eGamepadAxisMove;
+#endif
+}
+
+nsresult
+EventStateManager::PreHandleEvent(nsPresContext* aPresContext,
+                                  WidgetEvent* aEvent,
+                                  nsIFrame* aTargetFrame,
+                                  nsIContent* aTargetContent,
+                                  nsEventStatus* aStatus)
+{
+  NS_ENSURE_ARG_POINTER(aStatus);
+  NS_ENSURE_ARG(aPresContext);
+  if (!aEvent) {
+    NS_ERROR("aEvent is null.  This should never happen.");
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  NS_WARNING_ASSERTION(
+    !aTargetFrame || !aTargetFrame->GetContent() ||
+    aTargetFrame->GetContent() == aTargetContent ||
+    aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent ||
+    aTargetFrame->IsGeneratedContentFrame(),
+    "aTargetFrame should be related with aTargetContent");
+#if DEBUG
+  if (aTargetFrame && aTargetFrame->IsGeneratedContentFrame()) {
+    nsCOMPtr<nsIContent> targetContent;
+    aTargetFrame->GetContentForEvent(aEvent, getter_AddRefs(targetContent));
+    MOZ_ASSERT(aTargetContent == targetContent,
+               "Unexpected target for generated content frame!");
+  }
+#endif
+
+  mCurrentTarget = aTargetFrame;
+  mCurrentTargetContent = nullptr;
+
+  // Do not take account eMouseEnterIntoWidget/ExitFromWidget so that loading
+  // a page when user is not active doesn't change the state to active.
+  WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+  if (aEvent->IsTrusted() &&
+      ((mouseEvent && mouseEvent->IsReal() &&
+        IsMessageMouseUserActivity(mouseEvent->mMessage)) ||
+       aEvent->mClass == eWheelEventClass ||
+       aEvent->mClass == ePointerEventClass ||
+       aEvent->mClass == eTouchEventClass ||
+       aEvent->mClass == eKeyboardEventClass ||
+       IsMessageGamepadUserActivity(aEvent->mMessage))) {
+    if (gMouseOrKeyboardEventCounter == 0) {
+      nsCOMPtr<nsIObserverService> obs =
+        mozilla::services::GetObserverService();
+      if (obs) {
+        obs->NotifyObservers(nullptr, "user-interaction-active", nullptr);
+        UpdateUserActivityTimer();
+      }
+    }
+    ++gMouseOrKeyboardEventCounter;
+
+    nsCOMPtr<nsINode> node = do_QueryInterface(aTargetContent);
+    if (node &&
+        (aEvent->mMessage == eKeyUp || aEvent->mMessage == eMouseUp ||
+         aEvent->mMessage == eWheel || aEvent->mMessage == eTouchEnd ||
+         aEvent->mMessage == ePointerUp)) {
+      nsIDocument* doc = node->OwnerDoc();
+      while (doc && !doc->UserHasInteracted()) {
+        doc->SetUserHasInteracted(true);
+        doc = nsContentUtils::IsChildOfSameType(doc) ?
+          doc->GetParentDocument() : nullptr;
+      }
+    }
+  }
+
+  WheelTransaction::OnEvent(aEvent);
+
+  // Focus events don't necessarily need a frame.
+  if (!mCurrentTarget && !aTargetContent) {
+    NS_ERROR("mCurrentTarget and aTargetContent are null");
+    return NS_ERROR_NULL_POINTER;
+  }
+#ifdef DEBUG
+  if (aEvent->HasDragEventMessage() && sIsPointerLocked) {
+    NS_ASSERTION(sIsPointerLocked,
+      "sIsPointerLocked is true. Drag events should be suppressed when "
+      "the pointer is locked.");
+  }
+#endif
+  // Store last known screenPoint and clientPoint so pointer lock
+  // can use these values as constants.
+  if (aEvent->IsTrusted() &&
+      ((mouseEvent && mouseEvent->IsReal()) ||
+       aEvent->mClass == eWheelEventClass) &&
+      !sIsPointerLocked) {
+    sLastScreenPoint =
+      Event::GetScreenCoords(aPresContext, aEvent, aEvent->mRefPoint);
+    sLastClientPoint =
+      Event::GetClientCoords(aPresContext, aEvent, aEvent->mRefPoint,
+                             CSSIntPoint(0, 0));
+  }
+
+  *aStatus = nsEventStatus_eIgnore;
+
+  if (aEvent->mClass == eQueryContentEventClass) {
+    HandleQueryContentEvent(aEvent->AsQueryContentEvent());
+    return NS_OK;
+  }
+
+  WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
+  if (touchEvent && mInTouchDrag) {
+    if (touchEvent->mMessage == eTouchMove) {
+      GenerateDragGesture(aPresContext, touchEvent);
+    } else {
+      mInTouchDrag = false;
+      StopTrackingDragGesture();
+    }
+  }
+
+  switch (aEvent->mMessage) {
+  case eContextMenu:
+    if (sIsPointerLocked) {
+      return NS_ERROR_DOM_INVALID_STATE_ERR;
+    }
+    break;
+  case eMouseTouchDrag:
+    mInTouchDrag = true;
+    BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame);
+    break;
+  case eMouseDown: {
+    switch (mouseEvent->button) {
+    case WidgetMouseEvent::eLeftButton:
+      BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame);
+      mLClickCount = mouseEvent->mClickCount;
+      SetClickCount(mouseEvent, aStatus);
+      sNormalLMouseEventInProcess = true;
+      break;
+    case WidgetMouseEvent::eMiddleButton:
+      mMClickCount = mouseEvent->mClickCount;
+      SetClickCount(mouseEvent, aStatus);
+      break;
+    case WidgetMouseEvent::eRightButton:
+      mRClickCount = mouseEvent->mClickCount;
+      SetClickCount(mouseEvent, aStatus);
+      break;
+    }
+    break;
+  }
+  case eMouseUp: {
+    switch (mouseEvent->button) {
+      case WidgetMouseEvent::eLeftButton:
+        if (Prefs::ClickHoldContextMenu()) {
+          KillClickHoldTimer();
+        }
+        StopTrackingDragGesture();
+        sNormalLMouseEventInProcess = false;
+        // then fall through...
+        MOZ_FALLTHROUGH;
+      case WidgetMouseEvent::eRightButton:
+      case WidgetMouseEvent::eMiddleButton:
+        SetClickCount(mouseEvent, aStatus);
+        break;
+    }
+    break;
+  }
+  case eMouseEnterIntoWidget:
+    // In some cases on e10s eMouseEnterIntoWidget
+    // event was sent twice into child process of content.
+    // (From specific widget code (sending is not permanent) and
+    // from ESM::DispatchMouseOrPointerEvent (sending is permanent)).
+    // Flag mNoCrossProcessBoundaryForwarding helps to
+    // suppress sending accidental event from widget code.
+    aEvent->StopCrossProcessForwarding();
+    break;
+  case eMouseExitFromWidget:
+    // If this is a remote frame, we receive eMouseExitFromWidget from the
+    // parent the mouse exits our content. Since the parent may update the
+    // cursor while the mouse is outside our frame, and since PuppetWidget
+    // caches the current cursor internally, re-entering our content (say from
+    // over a window edge) wont update the cursor if the cached value and the
+    // current cursor match. So when the mouse exits a remote frame, clear the
+    // cached widget cursor so a proper update will occur when the mouse
+    // re-enters.
+    if (XRE_IsContentProcess()) {
+      ClearCachedWidgetCursor(mCurrentTarget);
+    }
+
+    // Flag helps to suppress double event sending into process of content.
+    // For more information see comment above, at eMouseEnterIntoWidget case.
+    aEvent->StopCrossProcessForwarding();
+
+    // If the event is not a top-level window exit, then it's not
+    // really an exit --- we may have traversed widget boundaries but
+    // we're still in our toplevel window.
+    if (mouseEvent->mExitFrom != WidgetMouseEvent::eTopLevel) {
+      // Treat it as a synthetic move so we don't generate spurious
+      // "exit" or "move" events.  Any necessary "out" or "over" events
+      // will be generated by GenerateMouseEnterExit
+      mouseEvent->mMessage = eMouseMove;
+      mouseEvent->mReason = WidgetMouseEvent::eSynthesized;
+      // then fall through...
+    } else {
+      if (sPointerEventEnabled) {
+        // We should synthetize corresponding pointer events
+        GeneratePointerEnterExit(ePointerLeave, mouseEvent);
+      }
+      GenerateMouseEnterExit(mouseEvent);
+      //This is a window level mouse exit event and should stop here
+      aEvent->mMessage = eVoidEvent;
+      break;
+    }
+    MOZ_FALLTHROUGH;
+  case eMouseMove:
+  case ePointerDown:
+  case ePointerMove: {
+    // on the Mac, GenerateDragGesture() may not return until the drag
+    // has completed and so |aTargetFrame| may have been deleted (moving
+    // a bookmark, for example).  If this is the case, however, we know
+    // that ClearFrameRefs() has been called and it cleared out
+    // |mCurrentTarget|. As a result, we should pass |mCurrentTarget|
+    // into UpdateCursor().
+    GenerateDragGesture(aPresContext, mouseEvent);
+    UpdateCursor(aPresContext, aEvent, mCurrentTarget, aStatus);
+    GenerateMouseEnterExit(mouseEvent);
+    // Flush pending layout changes, so that later mouse move events
+    // will go to the right nodes.
+    FlushPendingEvents(aPresContext);
+    break;
+  }
+  case eDragStart:
+    if (Prefs::ClickHoldContextMenu()) {
+      // an external drag gesture event came in, not generated internally
+      // by Gecko. Make sure we get rid of the click-hold timer.
+      KillClickHoldTimer();
+    }
+    break;
+  case eDragOver:
+    // Send the enter/exit events before eDrop.
+    GenerateDragDropEnterExit(aPresContext, aEvent->AsDragEvent());
+    break;
+
+  case eKeyPress:
+    {
+      WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
+
+      int32_t modifierMask = 0;
+      if (keyEvent->IsShift())
+        modifierMask |= NS_MODIFIER_SHIFT;
+      if (keyEvent->IsControl())
+        modifierMask |= NS_MODIFIER_CONTROL;
+      if (keyEvent->IsAlt())
+        modifierMask |= NS_MODIFIER_ALT;
+      if (keyEvent->IsMeta())
+        modifierMask |= NS_MODIFIER_META;
+      if (keyEvent->IsOS())
+        modifierMask |= NS_MODIFIER_OS;
+
+      // Prevent keyboard scrolling while an accesskey modifier is in use.
+      if (modifierMask) {
+        bool matchesContentAccessKey = (modifierMask == Prefs::ContentAccessModifierMask());
+        
+        if (modifierMask == Prefs::ChromeAccessModifierMask() ||
+            matchesContentAccessKey) {
+          AutoTArray<uint32_t, 10> accessCharCodes;
+          keyEvent->GetAccessKeyCandidates(accessCharCodes);
+
+          if (HandleAccessKey(keyEvent, aPresContext, accessCharCodes,
+                              modifierMask, matchesContentAccessKey)) {
+            *aStatus = nsEventStatus_eConsumeNoDefault;
+          }
+        }
+      }
+    }
+    // then fall through...
+    MOZ_FALLTHROUGH;
+  case eBeforeKeyDown:
+  case eKeyDown:
+  case eAfterKeyDown:
+  case eBeforeKeyUp:
+  case eKeyUp:
+  case eAfterKeyUp:
+    {
+      nsIContent* content = GetFocusedContent();
+      if (content)
+        mCurrentTargetContent = content;
+
+      // NOTE: Don't refer TextComposition::IsComposing() since UI Events
+      //       defines that KeyboardEvent.isComposing is true when it's
+      //       dispatched after compositionstart and compositionend.
+      //       TextComposition::IsComposing() is false even before
+      //       compositionend if there is no composing string.
+      //       And also don't expose other document's composition state.
+      //       A native IME context is typically shared by multiple documents.
+      //       So, don't use GetTextCompositionFor(nsIWidget*) here.
+      RefPtr<TextComposition> composition =
+        IMEStateManager::GetTextCompositionFor(aPresContext);
+      aEvent->AsKeyboardEvent()->mIsComposing = !!composition;
+    }
+    break;
+  case eWheel:
+  case eWheelOperationStart:
+  case eWheelOperationEnd:
+    {
+      NS_ASSERTION(aEvent->IsTrusted(),
+                   "Untrusted wheel event shouldn't be here");
+
+      nsIContent* content = GetFocusedContent();
+      if (content) {
+        mCurrentTargetContent = content;
+      }
+
+      if (aEvent->mMessage != eWheel) {
+        break;
+      }
+
+      WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
+      WheelPrefs::GetInstance()->ApplyUserPrefsToDelta(wheelEvent);
+
+      // If we won't dispatch a DOM event for this event, nothing to do anymore.
+      if (!wheelEvent->IsAllowedToDispatchDOMEvent()) {
+        break;
+      }
+
+      // Init lineOrPageDelta values for line scroll events for some devices
+      // on some platforms which might dispatch wheel events which don't have
+      // lineOrPageDelta values.  And also, if delta values are customized by
+      // prefs, this recomputes them.
+      DeltaAccumulator::GetInstance()->
+        InitLineOrPageDelta(aTargetFrame, this, wheelEvent);
+    }
+    break;
+  case eSetSelection:
+    IMEStateManager::HandleSelectionEvent(aPresContext, GetFocusedContent(),
+                                          aEvent->AsSelectionEvent());
+    break;
+  case eContentCommandCut:
+  case eContentCommandCopy:
+  case eContentCommandPaste:
+  case eContentCommandDelete:
+  case eContentCommandUndo:
+  case eContentCommandRedo:
+  case eContentCommandPasteTransferable:
+  case eContentCommandLookUpDictionary:
+    DoContentCommandEvent(aEvent->AsContentCommandEvent());
+    break;
+  case eContentCommandScroll:
+    DoContentCommandScrollEvent(aEvent->AsContentCommandEvent());
+    break;
+  case eCompositionStart:
+    if (aEvent->IsTrusted()) {
+      // If the event is trusted event, set the selected text to data of
+      // composition event.
+      WidgetCompositionEvent* compositionEvent = aEvent->AsCompositionEvent();
+      WidgetQueryContentEvent selectedText(true, eQuerySelectedText,
+                                           compositionEvent->mWidget);
+      HandleQueryContentEvent(&selectedText);
+      NS_ASSERTION(selectedText.mSucceeded, "Failed to get selected text");
+      compositionEvent->mData = selectedText.mReply.mString;
+    }
+    break;
+  default:
+    break;
+  }
+  return NS_OK;
+}
+
+void
+EventStateManager::HandleQueryContentEvent(WidgetQueryContentEvent* aEvent)
+{
+  switch (aEvent->mMessage) {
+    case eQuerySelectedText:
+    case eQueryTextContent:
+    case eQueryCaretRect:
+    case eQueryTextRect:
+    case eQueryEditorRect:
+      if (!IsTargetCrossProcess(aEvent)) {
+        break;
+      }
+      // Will not be handled locally, remote the event
+      GetCrossProcessTarget()->HandleQueryContentEvent(*aEvent);
+      return;
+    // Following events have not been supported in e10s mode yet.
+    case eQueryContentState:
+    case eQuerySelectionAsTransferable:
+    case eQueryCharacterAtPoint:
+    case eQueryDOMWidgetHittest:
+    case eQueryTextRectArray:
+      break;
+    default:
+      return;
+  }
+
+  // If there is an IMEContentObserver, we need to handle QueryContentEvent
+  // with it.
+  if (mIMEContentObserver) {
+    RefPtr<IMEContentObserver> contentObserver = mIMEContentObserver;
+    contentObserver->HandleQueryContentEvent(aEvent);
+    return;
+  }
+
+  ContentEventHandler handler(mPresContext);
+  handler.HandleQueryContentEvent(aEvent);
+}
+
+// static
+int32_t
+EventStateManager::GetAccessModifierMaskFor(nsISupports* aDocShell)
+{
+  nsCOMPtr<nsIDocShellTreeItem> treeItem(do_QueryInterface(aDocShell));
+  if (!treeItem)
+    return -1; // invalid modifier
+
+  switch (treeItem->ItemType()) {
+  case nsIDocShellTreeItem::typeChrome:
+    return Prefs::ChromeAccessModifierMask();
+
+  case nsIDocShellTreeItem::typeContent:
+    return Prefs::ContentAccessModifierMask();
+
+  default:
+    return -1; // invalid modifier
+  }
+}
+
+static bool
+IsAccessKeyTarget(nsIContent* aContent, nsIFrame* aFrame, nsAString& aKey)
+{
+  // Use GetAttr because we want Unicode case=insensitive matching
+  // XXXbz shouldn't this be case-sensitive, per spec?
+  nsString contentKey;
+  if (!aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, contentKey) ||
+      !contentKey.Equals(aKey, nsCaseInsensitiveStringComparator()))
+    return false;
+
+  nsCOMPtr<nsIDOMXULDocument> xulDoc =
+    do_QueryInterface(aContent->OwnerDoc());
+  if (!xulDoc && !aContent->IsXULElement())
+    return true;
+
+    // For XUL we do visibility checks.
+  if (!aFrame)
+    return false;
+
+  if (aFrame->IsFocusable())
+    return true;
+
+  if (!aFrame->IsVisibleConsideringAncestors())
+    return false;
+
+  // XUL controls can be activated.
+  nsCOMPtr<nsIDOMXULControlElement> control(do_QueryInterface(aContent));
+  if (control)
+    return true;
+
+  // HTML area, label and legend elements are never focusable, so
+  // we need to check for them explicitly before giving up.
+  if (aContent->IsAnyOfHTMLElements(nsGkAtoms::area,
+                                    nsGkAtoms::label,
+                                    nsGkAtoms::legend)) {
+    return true;
+  }
+
+  // XUL label elements are never focusable, so we need to check for them
+  // explicitly before giving up.
+  if (aContent->IsXULElement(nsGkAtoms::label)) {
+    return true;
+  }
+
+  return false;
+}
+
+bool
+EventStateManager::ExecuteAccessKey(nsTArray<uint32_t>& aAccessCharCodes,
+                                    bool aIsTrustedEvent)
+{
+  int32_t count, start = -1;
+  nsIContent* focusedContent = GetFocusedContent();
+  if (focusedContent) {
+    start = mAccessKeys.IndexOf(focusedContent);
+    if (start == -1 && focusedContent->GetBindingParent())
+      start = mAccessKeys.IndexOf(focusedContent->GetBindingParent());
+  }
+  nsIContent *content;
+  nsIFrame *frame;
+  int32_t length = mAccessKeys.Count();
+  for (uint32_t i = 0; i < aAccessCharCodes.Length(); ++i) {
+    uint32_t ch = aAccessCharCodes[i];
+    nsAutoString accessKey;
+    AppendUCS4ToUTF16(ch, accessKey);
+    for (count = 1; count <= length; ++count) {
+      content = mAccessKeys[(start + count) % length];
+      frame = content->GetPrimaryFrame();
+      if (IsAccessKeyTarget(content, frame, accessKey)) {
+        bool shouldActivate = Prefs::KeyCausesActivation();
+        while (shouldActivate && ++count <= length) {
+          nsIContent *oc = mAccessKeys[(start + count) % length];
+          nsIFrame *of = oc->GetPrimaryFrame();
+          if (IsAccessKeyTarget(oc, of, accessKey))
+            shouldActivate = false;
+        }
+
+        bool focusChanged = false;
+        if (shouldActivate) {
+          focusChanged = content->PerformAccesskey(shouldActivate, aIsTrustedEvent);
+        } else {
+          nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+          if (fm) {
+            nsCOMPtr<nsIDOMElement> element = do_QueryInterface(content);
+            fm->SetFocus(element, nsIFocusManager::FLAG_BYKEY);
+            focusChanged = true;
+          }
+        }
+
+        if (focusChanged && aIsTrustedEvent) {
+          // If this is a child process, inform the parent that we want the focus, but
+          // pass false since we don't want to change the window order.
+          nsIDocShell* docShell = mPresContext->GetDocShell();
+          nsCOMPtr<nsITabChild> child =
+            docShell ? docShell->GetTabChild() : nullptr;
+          if (child) {
+            child->SendRequestFocus(false);
+          }
+        }
+
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// static
+void
+EventStateManager::GetAccessKeyLabelPrefix(Element* aElement, nsAString& aPrefix)
+{
+  aPrefix.Truncate();
+  nsAutoString separator, modifierText;
+  nsContentUtils::GetModifierSeparatorText(separator);
+
+  nsCOMPtr<nsISupports> container = aElement->OwnerDoc()->GetDocShell();
+  int32_t modifierMask = GetAccessModifierMaskFor(container);
+
+  if (modifierMask == -1) {
+    return;
+  }
+
+  if (modifierMask & NS_MODIFIER_CONTROL) {
+    nsContentUtils::GetControlText(modifierText);
+    aPrefix.Append(modifierText + separator);
+  }
+  if (modifierMask & NS_MODIFIER_META) {
+    nsContentUtils::GetMetaText(modifierText);
+    aPrefix.Append(modifierText + separator);
+  }
+  if (modifierMask & NS_MODIFIER_OS) {
+    nsContentUtils::GetOSText(modifierText);
+    aPrefix.Append(modifierText + separator);
+  }
+  if (modifierMask & NS_MODIFIER_ALT) {
+    nsContentUtils::GetAltText(modifierText);
+    aPrefix.Append(modifierText + separator);
+  }
+  if (modifierMask & NS_MODIFIER_SHIFT) {
+    nsContentUtils::GetShiftText(modifierText);
+    aPrefix.Append(modifierText + separator);
+  }
+}
+
+struct MOZ_STACK_CLASS AccessKeyInfo
+{
+  WidgetKeyboardEvent* event;
+  nsTArray<uint32_t>& charCodes;
+  int32_t modifierMask;
+
+  AccessKeyInfo(WidgetKeyboardEvent* aEvent, nsTArray<uint32_t>& aCharCodes, int32_t aModifierMask)
+    : event(aEvent)
+    , charCodes(aCharCodes)
+    , modifierMask(aModifierMask)
+  {
+  }
+};
+
+static bool
+HandleAccessKeyInRemoteChild(TabParent* aTabParent, void* aArg)
+{
+  AccessKeyInfo* accessKeyInfo = static_cast<AccessKeyInfo*>(aArg);
+
+  // Only forward accesskeys for the active tab.
+  bool active;
+  aTabParent->GetDocShellIsActive(&active);
+  if (active) {
+    accessKeyInfo->event->mAccessKeyForwardedToChild = true;
+    aTabParent->HandleAccessKey(*accessKeyInfo->event,
+                                accessKeyInfo->charCodes,
+                                accessKeyInfo->modifierMask);
+    return true;
+  }
+
+  return false;
+}
+
+bool
+EventStateManager::HandleAccessKey(WidgetKeyboardEvent* aEvent,
+                                   nsPresContext* aPresContext,
+                                   nsTArray<uint32_t>& aAccessCharCodes,
+                                   bool aMatchesContentAccessKey,
+                                   nsIDocShellTreeItem* aBubbledFrom,
+                                   ProcessingAccessKeyState aAccessKeyState,
+                                   int32_t aModifierMask)
+{
+  EnsureDocument(mPresContext);
+  nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
+  if (NS_WARN_IF(!docShell) || NS_WARN_IF(!mDocument)) {
+    return false;
+  }
+
+  // Alt or other accesskey modifier is down, we may need to do an accesskey.
+  if (mAccessKeys.Count() > 0 &&
+      aModifierMask == GetAccessModifierMaskFor(docShell)) {
+    // Someone registered an accesskey.  Find and activate it.
+    if (ExecuteAccessKey(aAccessCharCodes, aEvent->IsTrusted())) {
+      return true;
+    }
+  }
+
+  int32_t childCount;
+  docShell->GetChildCount(&childCount);
+  for (int32_t counter = 0; counter < childCount; counter++) {
+    // Not processing the child which bubbles up the handling
+    nsCOMPtr<nsIDocShellTreeItem> subShellItem;
+    docShell->GetChildAt(counter, getter_AddRefs(subShellItem));
+    if (aAccessKeyState == eAccessKeyProcessingUp &&
+        subShellItem == aBubbledFrom) {
+      continue;
+    }
+
+    nsCOMPtr<nsIDocShell> subDS = do_QueryInterface(subShellItem);
+    if (subDS && IsShellVisible(subDS)) {
+      nsCOMPtr<nsIPresShell> subPS = subDS->GetPresShell();
+
+      // Docshells need not have a presshell (eg. display:none
+      // iframes, docshells in transition between documents, etc).
+      if (!subPS) {
+        // Oh, well.  Just move on to the next child
+        continue;
+      }
+
+      nsPresContext *subPC = subPS->GetPresContext();
+
+      EventStateManager* esm =
+        static_cast<EventStateManager*>(subPC->EventStateManager());
+
+      if (esm &&
+          esm->HandleAccessKey(aEvent, subPC, aAccessCharCodes,
+                               aMatchesContentAccessKey, nullptr,
+                               eAccessKeyProcessingDown, aModifierMask)) {
+        return true;
+      }
+    }
+  }// if end . checking all sub docshell ends here.
+
+  // bubble up the process to the parent docshell if necessary
+  if (eAccessKeyProcessingDown != aAccessKeyState) {
+    nsCOMPtr<nsIDocShellTreeItem> parentShellItem;
+    docShell->GetParent(getter_AddRefs(parentShellItem));
+    nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(parentShellItem);
+    if (parentDS) {
+      nsCOMPtr<nsIPresShell> parentPS = parentDS->GetPresShell();
+      NS_ASSERTION(parentPS, "Our PresShell exists but the parent's does not?");
+
+      nsPresContext *parentPC = parentPS->GetPresContext();
+      NS_ASSERTION(parentPC, "PresShell without PresContext");
+
+      EventStateManager* esm =
+        static_cast<EventStateManager*>(parentPC->EventStateManager());
+      if (esm &&
+          esm->HandleAccessKey(aEvent, parentPC, aAccessCharCodes,
+                               aMatchesContentAccessKey, docShell,
+                               eAccessKeyProcessingDown, aModifierMask)) {
+        return true;
+      }
+    }
+  }// if end. bubble up process
+
+  // If the content access key modifier is pressed, try remote children
+  if (aMatchesContentAccessKey && mDocument && mDocument->GetWindow()) {
+    // If the focus is currently on a node with a TabParent, the key event will
+    // get forwarded to the child process and HandleAccessKey called from there.
+    // If focus is somewhere else, then we need to check the remote children.
+    nsFocusManager* fm = nsFocusManager::GetFocusManager();
+    nsIContent* focusedContent = fm ? fm->GetFocusedContent() : nullptr;
+    if (TabParent::GetFrom(focusedContent)) {
+      // A remote child process is focused. The key event should get sent to
+      // the child process.
+      aEvent->mAccessKeyForwardedToChild = true;
+    } else {
+      AccessKeyInfo accessKeyInfo(aEvent, aAccessCharCodes, aModifierMask);
+      nsContentUtils::CallOnAllRemoteChildren(mDocument->GetWindow(),
+                                              HandleAccessKeyInRemoteChild, &accessKeyInfo);
+    }
+  }
+
+  return false;
+}// end of HandleAccessKey
+
+bool
+EventStateManager::DispatchCrossProcessEvent(WidgetEvent* aEvent,
+                                             nsFrameLoader* aFrameLoader,
+                                             nsEventStatus *aStatus) {
+  TabParent* remote = TabParent::GetFrom(aFrameLoader);
+  if (!remote) {
+    return false;
+  }
+
+  switch (aEvent->mClass) {
+  case eMouseEventClass: {
+    return remote->SendRealMouseEvent(*aEvent->AsMouseEvent());
+  }
+  case eKeyboardEventClass: {
+    return remote->SendRealKeyEvent(*aEvent->AsKeyboardEvent());
+  }
+  case eWheelEventClass: {
+    return remote->SendMouseWheelEvent(*aEvent->AsWheelEvent());
+  }
+  case eTouchEventClass: {
+    // Let the child process synthesize a mouse event if needed, and
+    // ensure we don't synthesize one in this process.
+    *aStatus = nsEventStatus_eConsumeNoDefault;
+    return remote->SendRealTouchEvent(*aEvent->AsTouchEvent());
+  }
+  case eDragEventClass: {
+    RefPtr<TabParent> tabParent = remote;
+    if (tabParent->Manager()->IsContentParent()) {
+      tabParent->Manager()->AsContentParent()->MaybeInvokeDragSession(tabParent);
+    }
+
+    nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+    uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
+    uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE;
+    if (dragSession) {
+      dragSession->DragEventDispatchedToChildProcess();
+      dragSession->GetDragAction(&action);
+      nsCOMPtr<nsIDOMDataTransfer> initialDataTransfer;
+      dragSession->GetDataTransfer(getter_AddRefs(initialDataTransfer));
+      if (initialDataTransfer) {
+        initialDataTransfer->GetDropEffectInt(&dropEffect);
+      }
+    }
+
+    bool retval = tabParent->SendRealDragEvent(*aEvent->AsDragEvent(),
+                                               action, dropEffect);
+
+    return retval;
+  }
+  case ePluginEventClass: {
+    *aStatus = nsEventStatus_eConsumeNoDefault;
+    return remote->SendPluginEvent(*aEvent->AsPluginEvent());
+  }
+  default: {
+    MOZ_CRASH("Attempt to send non-whitelisted event?");
+  }
+  }
+}
+
+bool
+EventStateManager::IsRemoteTarget(nsIContent* target) {
+  if (!target) {
+    return false;
+  }
+
+  // <browser/iframe remote=true> from XUL
+  if (target->IsAnyOfXULElements(nsGkAtoms::browser, nsGkAtoms::iframe) &&
+      target->AttrValueIs(kNameSpaceID_None, nsGkAtoms::Remote,
+                          nsGkAtoms::_true, eIgnoreCase)) {
+    return true;
+  }
+
+  // <frame/iframe mozbrowser/mozapp>
+  nsCOMPtr<nsIMozBrowserFrame> browserFrame = do_QueryInterface(target);
+  if (browserFrame && browserFrame->GetReallyIsBrowserOrApp()) {
+    return !!TabParent::GetFrom(target);
+  }
+
+  return false;
+}
+
+static bool
+CrossProcessSafeEvent(const WidgetEvent& aEvent)
+{
+  switch (aEvent.mClass) {
+  case eKeyboardEventClass:
+  case eWheelEventClass:
+    return true;
+  case eMouseEventClass:
+    switch (aEvent.mMessage) {
+    case eMouseDown:
+    case eMouseUp:
+    case eMouseMove:
+    case eContextMenu:
+    case eMouseEnterIntoWidget:
+    case eMouseExitFromWidget:
+    case eMouseTouchDrag:
+      return true;
+    default:
+      return false;
+    }
+  case eTouchEventClass:
+    switch (aEvent.mMessage) {
+    case eTouchStart:
+    case eTouchMove:
+    case eTouchEnd:
+    case eTouchCancel:
+      return true;
+    default:
+      return false;
+    }
+  case eDragEventClass:
+    switch (aEvent.mMessage) {
+    case eDragOver:
+    case eDragExit:
+    case eDrop:
+      return true;
+    default:
+      return false;
+    }
+  default:
+    return false;
+  }
+}
+
+bool
+EventStateManager::HandleCrossProcessEvent(WidgetEvent* aEvent,
+                                           nsEventStatus *aStatus) {
+  if (*aStatus == nsEventStatus_eConsumeNoDefault ||
+      aEvent->mFlags.mNoCrossProcessBoundaryForwarding ||
+      !CrossProcessSafeEvent(*aEvent)) {
+    return false;
+  }
+
+  // Collect the remote event targets we're going to forward this
+  // event to.
+  //
+  // NB: the elements of |targets| must be unique, for correctness.
+  AutoTArray<nsCOMPtr<nsIContent>, 1> targets;
+  if (aEvent->mClass != eTouchEventClass || aEvent->mMessage == eTouchStart) {
+    // If this event only has one target, and it's remote, add it to
+    // the array.
+    nsIFrame* frame =
+      aEvent->mMessage == eDragExit ? sLastDragOverFrame.GetFrame() : GetEventTarget();
+    nsIContent* target = frame ? frame->GetContent() : nullptr;
+    if (IsRemoteTarget(target)) {
+      targets.AppendElement(target);
+    }
+  } else {
+    // This is a touch event with possibly multiple touch points.
+    // Each touch point may have its own target.  So iterate through
+    // all of them and collect the unique set of targets for event
+    // forwarding.
+    //
+    // This loop is similar to the one used in
+    // PresShell::DispatchTouchEvent().
+    const WidgetTouchEvent::TouchArray& touches =
+      aEvent->AsTouchEvent()->mTouches;
+    for (uint32_t i = 0; i < touches.Length(); ++i) {
+      Touch* touch = touches[i];
+      // NB: the |mChanged| check is an optimization, subprocesses can
+      // compute this for themselves.  If the touch hasn't changed, we
+      // may be able to avoid forwarding the event entirely (which is
+      // not free).
+      if (!touch || !touch->mChanged) {
+        continue;
+      }
+      nsCOMPtr<EventTarget> targetPtr = touch->mTarget;
+      if (!targetPtr) {
+        continue;
+      }
+      nsCOMPtr<nsIContent> target = do_QueryInterface(targetPtr);
+      if (IsRemoteTarget(target) && !targets.Contains(target)) {
+        targets.AppendElement(target);
+      }
+    }
+  }
+
+  if (targets.Length() == 0) {
+    return false;
+  }
+
+  // Look up the frame loader for all the remote targets we found, and
+  // then dispatch the event to the remote content they represent.
+  bool dispatched = false;
+  for (uint32_t i = 0; i < targets.Length(); ++i) {
+    nsIContent* target = targets[i];
+    nsCOMPtr<nsIFrameLoaderOwner> loaderOwner = do_QueryInterface(target);
+    if (!loaderOwner) {
+      continue;
+    }
+
+    RefPtr<nsFrameLoader> frameLoader = loaderOwner->GetFrameLoader();
+    if (!frameLoader) {
+      continue;
+    }
+
+    uint32_t eventMode;
+    frameLoader->GetEventMode(&eventMode);
+    if (eventMode == nsIFrameLoader::EVENT_MODE_DONT_FORWARD_TO_CHILD) {
+      continue;
+    }
+
+    dispatched |= DispatchCrossProcessEvent(aEvent, frameLoader, aStatus);
+  }
+  return dispatched;
+}
+
+//
+// CreateClickHoldTimer
+//
+// Fire off a timer for determining if the user wants click-hold. This timer
+// is a one-shot that will be cancelled when the user moves enough to fire
+// a drag.
+//
+void
+EventStateManager::CreateClickHoldTimer(nsPresContext* inPresContext,
+                                        nsIFrame* inDownFrame,
+                                        WidgetGUIEvent* inMouseDownEvent)
+{
+  if (!inMouseDownEvent->IsTrusted() ||
+      IsRemoteTarget(mGestureDownContent) ||
+      sIsPointerLocked) {
+    return;
+  }
+
+  // just to be anal (er, safe)
+  if (mClickHoldTimer) {
+    mClickHoldTimer->Cancel();
+    mClickHoldTimer = nullptr;
+  }
+
+  // if content clicked on has a popup, don't even start the timer
+  // since we'll end up conflicting and both will show.
+  if (mGestureDownContent) {
+    // check for the |popup| attribute
+    if (nsContentUtils::HasNonEmptyAttr(mGestureDownContent, kNameSpaceID_None,
+                                        nsGkAtoms::popup))
+      return;
+    
+    // check for a <menubutton> like bookmarks
+    if (mGestureDownContent->IsXULElement(nsGkAtoms::menubutton))
+      return;
+  }
+
+  mClickHoldTimer = do_CreateInstance("@mozilla.org/timer;1");
+  if (mClickHoldTimer) {
+    int32_t clickHoldDelay =
+      Preferences::GetInt("ui.click_hold_context_menus.delay", 500);
+    mClickHoldTimer->InitWithFuncCallback(sClickHoldCallback, this,
+                                          clickHoldDelay,
+                                          nsITimer::TYPE_ONE_SHOT);
+  }
+} // CreateClickHoldTimer
+
+//
+// KillClickHoldTimer
+//
+// Stop the timer that would show the context menu dead in its tracks
+//
+void
+EventStateManager::KillClickHoldTimer()
+{
+  if (mClickHoldTimer) {
+    mClickHoldTimer->Cancel();
+    mClickHoldTimer = nullptr;
+  }
+}
+
+//
+// sClickHoldCallback
+//
+// This fires after the mouse has been down for a certain length of time.
+//
+void
+EventStateManager::sClickHoldCallback(nsITimer* aTimer, void* aESM)
+{
+  RefPtr<EventStateManager> self = static_cast<EventStateManager*>(aESM);
+  if (self) {
+    self->FireContextClick();
+  }
+
+  // NOTE: |aTimer| and |self->mAutoHideTimer| are invalid after calling ClosePopup();
+
+} // sAutoHideCallback
+
+//
+// FireContextClick
+//
+// If we're this far, our timer has fired, which means the mouse has been down
+// for a certain period of time and has not moved enough to generate a dragGesture.
+// We can be certain the user wants a context-click at this stage, so generate
+// a dom event and fire it in.
+//
+// After the event fires, check if PreventDefault() has been set on the event which
+// means that someone either ate the event or put up a context menu. This is our cue
+// to stop tracking the drag gesture. If we always did this, draggable items w/out
+// a context menu wouldn't be draggable after a certain length of time, which is
+// _not_ what we want.
+//
+void
+EventStateManager::FireContextClick()
+{
+  if (!mGestureDownContent || !mPresContext || sIsPointerLocked) {
+    return;
+  }
+
+#ifdef XP_MACOSX
+  // Hack to ensure that we don't show a context menu when the user
+  // let go of the mouse after a long cpu-hogging operation prevented
+  // us from handling any OS events. See bug 117589.
+  if (!CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState, kCGMouseButtonLeft))
+    return;
+#endif
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+
+  // Dispatch to the DOM. We have to fake out the ESM and tell it that the
+  // current target frame is actually where the mouseDown occurred, otherwise it
+  // will use the frame the mouse is currently over which may or may not be
+  // the same. (Note: saari and I have decided that we don't have to reset |mCurrentTarget|
+  // when we're through because no one else is doing anything more with this
+  // event and it will get reset on the very next event to the correct frame).
+  mCurrentTarget = mPresContext->GetPrimaryFrameFor(mGestureDownContent);
+  // make sure the widget sticks around
+  nsCOMPtr<nsIWidget> targetWidget;
+  if (mCurrentTarget && (targetWidget = mCurrentTarget->GetNearestWidget())) {
+    NS_ASSERTION(mPresContext == mCurrentTarget->PresContext(),
+                 "a prescontext returned a primary frame that didn't belong to it?");
+
+    // before dispatching, check that we're not on something that
+    // doesn't get a context menu
+    bool allowedToDispatch = true;
+
+    if (mGestureDownContent->IsAnyOfXULElements(nsGkAtoms::scrollbar,
+                                                nsGkAtoms::scrollbarbutton,
+                                                nsGkAtoms::button)) {
+      allowedToDispatch = false;
+    } else if (mGestureDownContent->IsXULElement(nsGkAtoms::toolbarbutton)) {
+      // a <toolbarbutton> that has the container attribute set
+      // will already have its own dropdown.
+      if (nsContentUtils::HasNonEmptyAttr(mGestureDownContent,
+              kNameSpaceID_None, nsGkAtoms::container)) {
+        allowedToDispatch = false;
+      } else {
+        // If the toolbar button has an open menu, don't attempt to open
+          // a second menu
+        if (mGestureDownContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
+                                             nsGkAtoms::_true, eCaseMatters)) {
+          allowedToDispatch = false;
+        }
+      }
+    }
+    else if (mGestureDownContent->IsHTMLElement()) {
+      nsCOMPtr<nsIFormControl> formCtrl(do_QueryInterface(mGestureDownContent));
+
+      if (formCtrl) {
+        allowedToDispatch = formCtrl->IsTextOrNumberControl(/*aExcludePassword*/ false) ||
+                            formCtrl->GetType() == NS_FORM_INPUT_FILE;
+      }
+      else if (mGestureDownContent->IsAnyOfHTMLElements(nsGkAtoms::applet,
+                                                        nsGkAtoms::embed,
+                                                        nsGkAtoms::object,
+                                                        nsGkAtoms::label)) {
+        allowedToDispatch = false;
+      }
+    }
+
+    if (allowedToDispatch) {
+      // init the event while mCurrentTarget is still good
+      WidgetMouseEvent event(true, eContextMenu, targetWidget,
+                             WidgetMouseEvent::eReal);
+      event.mClickCount = 1;
+      FillInEventFromGestureDown(&event);
+        
+      // stop selection tracking, we're in control now
+      if (mCurrentTarget)
+      {
+        RefPtr<nsFrameSelection> frameSel =
+          mCurrentTarget->GetFrameSelection();
+        
+        if (frameSel && frameSel->GetDragState()) {
+          // note that this can cause selection changed events to fire if we're in
+          // a text field, which will null out mCurrentTarget
+          frameSel->SetDragState(false);
+        }
+      }
+
+      nsIDocument* doc = mGestureDownContent->GetComposedDoc();
+      AutoHandlingUserInputStatePusher userInpStatePusher(true, &event, doc);
+
+      // dispatch to DOM
+      EventDispatcher::Dispatch(mGestureDownContent, mPresContext, &event,
+                                nullptr, &status);
+
+      // We don't need to dispatch to frame handling because no frames
+      // watch eContextMenu except for nsMenuFrame and that's only for
+      // dismissal. That's just as well since we don't really know
+      // which frame to send it to.
+    }
+  }
+
+  // now check if the event has been handled. If so, stop tracking a drag
+  if (status == nsEventStatus_eConsumeNoDefault) {
+    StopTrackingDragGesture();
+  }
+
+  KillClickHoldTimer();
+
+} // FireContextClick
+
+//
+// BeginTrackingDragGesture
+//
+// Record that the mouse has gone down and that we should move to TRACKING state
+// of d&d gesture tracker.
+//
+// We also use this to track click-hold context menus. When the mouse goes down,
+// fire off a short timer. If the timer goes off and we have yet to fire the
+// drag gesture (ie, the mouse hasn't moved a certain distance), then we can
+// assume the user wants a click-hold, so fire a context-click event. We only
+// want to cancel the drag gesture if the context-click event is handled.
+//
+void
+EventStateManager::BeginTrackingDragGesture(nsPresContext* aPresContext,
+                                            WidgetMouseEvent* inDownEvent,
+                                            nsIFrame* inDownFrame)
+{
+  if (!inDownEvent->mWidget) {
+    return;
+  }
+
+  // Note that |inDownEvent| could be either a mouse down event or a
+  // synthesized mouse move event.
+  mGestureDownPoint =
+    inDownEvent->mRefPoint + inDownEvent->mWidget->WidgetToScreenOffset();
+
+  if (inDownFrame) {
+    inDownFrame->GetContentForEvent(inDownEvent,
+                                    getter_AddRefs(mGestureDownContent));
+
+    mGestureDownFrameOwner = inDownFrame->GetContent();
+    if (!mGestureDownFrameOwner) {
+      mGestureDownFrameOwner = mGestureDownContent;
+    }
+  }
+  mGestureModifiers = inDownEvent->mModifiers;
+  mGestureDownButtons = inDownEvent->buttons;
+
+  if (inDownEvent->mMessage != eMouseTouchDrag && Prefs::ClickHoldContextMenu()) {
+    // fire off a timer to track click-hold
+    CreateClickHoldTimer(aPresContext, inDownFrame, inDownEvent);
+  }
+}
+
+void
+EventStateManager::BeginTrackingRemoteDragGesture(nsIContent* aContent)
+{
+  mGestureDownContent = aContent;
+  mGestureDownFrameOwner = aContent;
+}
+
+//
+// StopTrackingDragGesture
+//
+// Record that the mouse has gone back up so that we should leave the TRACKING
+// state of d&d gesture tracker and return to the START state.
+//
+void
+EventStateManager::StopTrackingDragGesture()
+{
+  mGestureDownContent = nullptr;
+  mGestureDownFrameOwner = nullptr;
+}
+
+void
+EventStateManager::FillInEventFromGestureDown(WidgetMouseEvent* aEvent)
+{
+  NS_ASSERTION(aEvent->mWidget == mCurrentTarget->GetNearestWidget(),
+               "Incorrect widget in event");
+
+  // Set the coordinates in the new event to the coordinates of
+  // the old event, adjusted for the fact that the widget might be
+  // different
+  aEvent->mRefPoint =
+    mGestureDownPoint - aEvent->mWidget->WidgetToScreenOffset();
+  aEvent->mModifiers = mGestureModifiers;
+  aEvent->buttons = mGestureDownButtons;
+}
+
+//
+// GenerateDragGesture
+//
+// If we're in the TRACKING state of the d&d gesture tracker, check the current position
+// of the mouse in relation to the old one. If we've moved a sufficient amount from
+// the mouse down, then fire off a drag gesture event.
+void
+EventStateManager::GenerateDragGesture(nsPresContext* aPresContext,
+                                       WidgetInputEvent* aEvent)
+{
+  NS_ASSERTION(aPresContext, "This shouldn't happen.");
+  if (IsTrackingDragGesture()) {
+    mCurrentTarget = mGestureDownFrameOwner->GetPrimaryFrame();
+
+    if (!mCurrentTarget || !mCurrentTarget->GetNearestWidget()) {
+      StopTrackingDragGesture();
+      return;
+    }
+
+    // Check if selection is tracking drag gestures, if so
+    // don't interfere!
+    if (mCurrentTarget)
+    {
+      RefPtr<nsFrameSelection> frameSel = mCurrentTarget->GetFrameSelection();
+      if (frameSel && frameSel->GetDragState()) {
+        StopTrackingDragGesture();
+        return;
+      }
+    }
+
+    // If non-native code is capturing the mouse don't start a drag.
+    if (nsIPresShell::IsMouseCapturePreventingDrag()) {
+      StopTrackingDragGesture();
+      return;
+    }
+
+    static int32_t pixelThresholdX = 0;
+    static int32_t pixelThresholdY = 0;
+
+    if (!pixelThresholdX) {
+      pixelThresholdX =
+        LookAndFeel::GetInt(LookAndFeel::eIntID_DragThresholdX, 0);
+      pixelThresholdY =
+        LookAndFeel::GetInt(LookAndFeel::eIntID_DragThresholdY, 0);
+      if (!pixelThresholdX)
+        pixelThresholdX = 5;
+      if (!pixelThresholdY)
+        pixelThresholdY = 5;
+    }
+
+    // fire drag gesture if mouse has moved enough
+    LayoutDeviceIntPoint pt = aEvent->mWidget->WidgetToScreenOffset() +
+      (aEvent->AsTouchEvent() ? aEvent->AsTouchEvent()->mTouches[0]->mRefPoint
+                              : aEvent->mRefPoint);
+    LayoutDeviceIntPoint distance = pt - mGestureDownPoint;
+    if (Abs(distance.x) > AssertedCast<uint32_t>(pixelThresholdX) ||
+        Abs(distance.y) > AssertedCast<uint32_t>(pixelThresholdY)) {
+      if (Prefs::ClickHoldContextMenu()) {
+        // stop the click-hold before we fire off the drag gesture, in case
+        // it takes a long time
+        KillClickHoldTimer();
+      }
+
+      nsCOMPtr<nsIDocShell> docshell = aPresContext->GetDocShell();
+      if (!docshell) {
+        return;
+      }
+
+      nsCOMPtr<nsPIDOMWindowOuter> window = docshell->GetWindow();
+      if (!window)
+        return;
+
+      RefPtr<DataTransfer> dataTransfer =
+        new DataTransfer(window, eDragStart, false, -1);
+
+      nsCOMPtr<nsISelection> selection;
+      nsCOMPtr<nsIContent> eventContent, targetContent;
+      mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(eventContent));
+      if (eventContent)
+        DetermineDragTargetAndDefaultData(window, eventContent, dataTransfer,
+                                          getter_AddRefs(selection),
+                                          getter_AddRefs(targetContent));
+
+      // Stop tracking the drag gesture now. This should stop us from
+      // reentering GenerateDragGesture inside DOM event processing.
+      StopTrackingDragGesture();
+
+      if (!targetContent)
+        return;
+
+      // Use our targetContent, now that we've determined it, as the
+      // parent object of the DataTransfer.
+      dataTransfer->SetParentObject(targetContent);
+
+      sLastDragOverFrame = nullptr;
+      nsCOMPtr<nsIWidget> widget = mCurrentTarget->GetNearestWidget();
+
+      // get the widget from the target frame
+      WidgetDragEvent startEvent(aEvent->IsTrusted(), eDragStart, widget);
+      FillInEventFromGestureDown(&startEvent);
+
+      startEvent.mDataTransfer = dataTransfer;
+      if (aEvent->AsMouseEvent()) {
+        startEvent.inputSource = aEvent->AsMouseEvent()->inputSource;
+      } else if (aEvent->AsTouchEvent()) {
+        startEvent.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
+      } else {
+        MOZ_ASSERT(false);
+      }
+
+      // Dispatch to the DOM. By setting mCurrentTarget we are faking
+      // out the ESM and telling it that the current target frame is
+      // actually where the mouseDown occurred, otherwise it will use
+      // the frame the mouse is currently over which may or may not be
+      // the same. (Note: saari and I have decided that we don't have
+      // to reset |mCurrentTarget| when we're through because no one
+      // else is doing anything more with this event and it will get
+      // reset on the very next event to the correct frame).
+
+      // Hold onto old target content through the event and reset after.
+      nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;
+
+      // Set the current target to the content for the mouse down
+      mCurrentTargetContent = targetContent;
+
+      // Dispatch the dragstart event to the DOM.
+      nsEventStatus status = nsEventStatus_eIgnore;
+      EventDispatcher::Dispatch(targetContent, aPresContext, &startEvent,
+                                nullptr, &status);
+
+      WidgetDragEvent* event = &startEvent;
+
+      nsCOMPtr<nsIObserverService> observerService =
+        mozilla::services::GetObserverService();
+      // Emit observer event to allow addons to modify the DataTransfer object.
+      if (observerService) {
+        observerService->NotifyObservers(dataTransfer,
+                                         "on-datatransfer-available",
+                                         nullptr);
+      }
+
+      // now that the dataTransfer has been updated in the dragstart and
+      // draggesture events, make it read only so that the data doesn't
+      // change during the drag.
+      dataTransfer->SetReadOnly();
+
+      if (status != nsEventStatus_eConsumeNoDefault) {
+        bool dragStarted = DoDefaultDragStart(aPresContext, event, dataTransfer,
+                                              targetContent, selection);
+        if (dragStarted) {
+          sActiveESM = nullptr;
+          aEvent->StopPropagation();
+        }
+      }
+
+      // Reset mCurretTargetContent to what it was
+      mCurrentTargetContent = targetBeforeEvent;
+    }
+
+    // Now flush all pending notifications, for better responsiveness
+    // while dragging.
+    FlushPendingEvents(aPresContext);
+  }
+} // GenerateDragGesture
+
+void
+EventStateManager::DetermineDragTargetAndDefaultData(nsPIDOMWindowOuter* aWindow,
+                                                     nsIContent* aSelectionTarget,
+                                                     DataTransfer* aDataTransfer,
+                                                     nsISelection** aSelection,
+                                                     nsIContent** aTargetNode)
+{
+  *aTargetNode = nullptr;
+
+  // GetDragData determines if a selection, link or image in the content
+  // should be dragged, and places the data associated with the drag in the
+  // data transfer.
+  // mGestureDownContent is the node where the mousedown event for the drag
+  // occurred, and aSelectionTarget is the node to use when a selection is used
+  bool canDrag;
+  nsCOMPtr<nsIContent> dragDataNode;
+  bool wasAlt = (mGestureModifiers & MODIFIER_ALT) != 0;
+  nsresult rv = nsContentAreaDragDrop::GetDragData(aWindow, mGestureDownContent,
+                                                   aSelectionTarget, wasAlt,
+                                                   aDataTransfer, &canDrag, aSelection,
+                                                   getter_AddRefs(dragDataNode));
+  if (NS_FAILED(rv) || !canDrag)
+    return;
+
+  // if GetDragData returned a node, use that as the node being dragged.
+  // Otherwise, if a selection is being dragged, use the node within the
+  // selection that was dragged. Otherwise, just use the mousedown target.
+  nsIContent* dragContent = mGestureDownContent;
+  if (dragDataNode)
+    dragContent = dragDataNode;
+  else if (*aSelection)
+    dragContent = aSelectionTarget;
+
+  nsIContent* originalDragContent = dragContent;
+
+  // If a selection isn't being dragged, look for an ancestor with the
+  // draggable property set. If one is found, use that as the target of the
+  // drag instead of the node that was clicked on. If a draggable node wasn't
+  // found, just use the clicked node.
+  if (!*aSelection) {
+    while (dragContent) {
+      nsCOMPtr<nsIDOMHTMLElement> htmlElement = do_QueryInterface(dragContent);
+      if (htmlElement) {
+        bool draggable = false;
+        htmlElement->GetDraggable(&draggable);
+        if (draggable)
+          break;
+      }
+      else {
+        nsCOMPtr<nsIDOMXULElement> xulElement = do_QueryInterface(dragContent);
+        if (xulElement) {
+          // All XUL elements are draggable, so if a XUL element is
+          // encountered, stop looking for draggable nodes and just use the
+          // original clicked node instead.
+          // XXXndeakin
+          // In the future, we will want to improve this so that XUL has a
+          // better way to specify whether something is draggable than just
+          // on/off.
+          dragContent = mGestureDownContent;
+          break;
+        }
+        // otherwise, it's not an HTML or XUL element, so just keep looking
+      }
+      dragContent = dragContent->GetParent();
+    }
+  }
+
+  // if no node in the hierarchy was found to drag, but the GetDragData method
+  // returned a node, use that returned node. Otherwise, nothing is draggable.
+  if (!dragContent && dragDataNode)
+    dragContent = dragDataNode;
+
+  if (dragContent) {
+    // if an ancestor node was used instead, clear the drag data
+    // XXXndeakin rework this a bit. Find a way to just not call GetDragData if we don't need to.
+    if (dragContent != originalDragContent)
+      aDataTransfer->ClearAll();
+    *aTargetNode = dragContent;
+    NS_ADDREF(*aTargetNode);
+  }
+}
+
+bool
+EventStateManager::DoDefaultDragStart(nsPresContext* aPresContext,
+                                      WidgetDragEvent* aDragEvent,
+                                      DataTransfer* aDataTransfer,
+                                      nsIContent* aDragTarget,
+                                      nsISelection* aSelection)
+{
+  nsCOMPtr<nsIDragService> dragService =
+    do_GetService("@mozilla.org/widget/dragservice;1");
+  if (!dragService)
+    return false;
+
+  // Default handling for the dragstart event.
+  //
+  // First, check if a drag session already exists. This means that the drag
+  // service was called directly within a draggesture handler. In this case,
+  // don't do anything more, as it is assumed that the handler is managing
+  // drag and drop manually. Make sure to return true to indicate that a drag
+  // began.
+  nsCOMPtr<nsIDragSession> dragSession;
+  dragService->GetCurrentSession(getter_AddRefs(dragSession));
+  if (dragSession)
+    return true;
+
+  // No drag session is currently active, so check if a handler added
+  // any items to be dragged. If not, there isn't anything to drag.
+  uint32_t count = 0;
+  if (aDataTransfer)
+    aDataTransfer->GetMozItemCount(&count);
+  if (!count)
+    return false;
+
+  // Get the target being dragged, which may not be the same as the
+  // target of the mouse event. If one wasn't set in the
+  // aDataTransfer during the event handler, just use the original
+  // target instead.
+  nsCOMPtr<nsIContent> dragTarget = aDataTransfer->GetDragTarget();
+  if (!dragTarget) {
+    dragTarget = aDragTarget;
+    if (!dragTarget)
+      return false;
+  }
+
+  // check which drag effect should initially be used. If the effect was not
+  // set, just use all actions, otherwise Windows won't allow a drop.
+  uint32_t action;
+  aDataTransfer->GetEffectAllowedInt(&action);
+  if (action == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED)
+    action = nsIDragService::DRAGDROP_ACTION_COPY |
+             nsIDragService::DRAGDROP_ACTION_MOVE |
+             nsIDragService::DRAGDROP_ACTION_LINK;
+
+  // get any custom drag image that was set
+  int32_t imageX, imageY;
+  Element* dragImage = aDataTransfer->GetDragImage(&imageX, &imageY);
+
+  nsCOMPtr<nsIArray> transArray =
+    aDataTransfer->GetTransferables(dragTarget->AsDOMNode());
+  if (!transArray)
+    return false;
+
+  // XXXndeakin don't really want to create a new drag DOM event
+  // here, but we need something to pass to the InvokeDragSession
+  // methods.
+  RefPtr<DragEvent> event =
+    NS_NewDOMDragEvent(dragTarget, aPresContext, aDragEvent);
+
+  // Use InvokeDragSessionWithSelection if a selection is being dragged,
+  // such that the image can be generated from the selected text. However,
+  // use InvokeDragSessionWithImage if a custom image was set or something
+  // other than a selection is being dragged.
+  if (!dragImage && aSelection) {
+    dragService->InvokeDragSessionWithSelection(aSelection, transArray,
+                                                action, event, aDataTransfer);
+  }
+  else {
+    // if dragging within a XUL tree and no custom drag image was
+    // set, the region argument to InvokeDragSessionWithImage needs
+    // to be set to the area encompassing the selected rows of the
+    // tree to ensure that the drag feedback gets clipped to those
+    // rows. For other content, region should be null.
+    nsCOMPtr<nsIScriptableRegion> region;
+#ifdef MOZ_XUL
+    if (dragTarget && !dragImage) {
+      if (dragTarget->NodeInfo()->Equals(nsGkAtoms::treechildren,
+                                         kNameSpaceID_XUL)) {
+        nsTreeBodyFrame* treeBody =
+          do_QueryFrame(dragTarget->GetPrimaryFrame());
+        if (treeBody) {
+          treeBody->GetSelectionRegion(getter_AddRefs(region));
+        }
+      }
+    }
+#endif
+
+    dragService->InvokeDragSessionWithImage(dragTarget->AsDOMNode(), transArray,
+                                            region, action,
+                                            dragImage ? dragImage->AsDOMNode() :
+                                                        nullptr,
+                                            imageX, imageY, event,
+                                            aDataTransfer);
+  }
+
+  return true;
+}
+
+nsresult
+EventStateManager::GetContentViewer(nsIContentViewer** aCv)
+{
+  *aCv = nullptr;
+
+  nsPIDOMWindowOuter* window = mDocument->GetWindow();
+  if (!window) return NS_ERROR_FAILURE;
+  nsCOMPtr<nsPIDOMWindowOuter> rootWindow = window->GetPrivateRoot();
+  if (!rootWindow) return NS_ERROR_FAILURE;
+
+  TabChild* tabChild = TabChild::GetFrom(rootWindow);
+  if (!tabChild) {
+    nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+    if (!fm) return NS_ERROR_FAILURE;
+
+    nsCOMPtr<mozIDOMWindowProxy> activeWindow;
+    fm->GetActiveWindow(getter_AddRefs(activeWindow));
+    if (rootWindow != activeWindow) return NS_OK;
+  } else {
+    if (!tabChild->ParentIsActive()) return NS_OK;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> contentWindow = nsGlobalWindow::Cast(rootWindow)->GetContent();
+  if (!contentWindow) return NS_ERROR_FAILURE;
+
+  nsIDocument *doc = contentWindow->GetDoc();
+  if (!doc) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsISupports> container = doc->GetContainer();
+  if (!container) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDocShell> docshell = do_QueryInterface(container);
+  docshell->GetContentViewer(aCv);
+  if (!*aCv) return NS_ERROR_FAILURE;
+
+  return NS_OK;
+}
+
+nsresult
+EventStateManager::ChangeTextSize(int32_t change)
+{
+  nsCOMPtr<nsIContentViewer> cv;
+  nsresult rv = GetContentViewer(getter_AddRefs(cv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (cv) {
+    float textzoom;
+    float zoomMin = ((float)Preferences::GetInt("zoom.minPercent", 50)) / 100;
+    float zoomMax = ((float)Preferences::GetInt("zoom.maxPercent", 300)) / 100;
+    cv->GetTextZoom(&textzoom);
+    textzoom += ((float)change) / 10;
+    if (textzoom < zoomMin)
+      textzoom = zoomMin;
+    else if (textzoom > zoomMax)
+      textzoom = zoomMax;
+    cv->SetTextZoom(textzoom);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+EventStateManager::ChangeFullZoom(int32_t change)
+{
+  nsCOMPtr<nsIContentViewer> cv;
+  nsresult rv = GetContentViewer(getter_AddRefs(cv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (cv) {
+    float fullzoom;
+    float zoomMin = ((float)Preferences::GetInt("zoom.minPercent", 50)) / 100;
+    float zoomMax = ((float)Preferences::GetInt("zoom.maxPercent", 300)) / 100;
+    cv->GetFullZoom(&fullzoom);
+    fullzoom += ((float)change) / 10;
+    if (fullzoom < zoomMin)
+      fullzoom = zoomMin;
+    else if (fullzoom > zoomMax)
+      fullzoom = zoomMax;
+    cv->SetFullZoom(fullzoom);
+  }
+
+  return NS_OK;
+}
+
+void
+EventStateManager::DoScrollHistory(int32_t direction)
+{
+  nsCOMPtr<nsISupports> pcContainer(mPresContext->GetContainerWeak());
+  if (pcContainer) {
+    nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(pcContainer));
+    if (webNav) {
+      // positive direction to go back one step, nonpositive to go forward
+      if (direction > 0)
+        webNav->GoBack();
+      else
+        webNav->GoForward();
+    }
+  }
+}
+
+void
+EventStateManager::DoScrollZoom(nsIFrame* aTargetFrame,
+                                int32_t adjustment)
+{
+  // Exclude form controls and content in chrome docshells.
+  nsIContent *content = aTargetFrame->GetContent();
+  if (content &&
+      !content->IsNodeOfType(nsINode::eHTML_FORM_CONTROL) &&
+      !nsContentUtils::IsInChromeDocshell(content->OwnerDoc()))
+    {
+      // positive adjustment to decrease zoom, negative to increase
+      int32_t change = (adjustment > 0) ? -1 : 1;
+
+      EnsureDocument(mPresContext);
+      if (Preferences::GetBool("browser.zoom.full") || content->OwnerDoc()->IsSyntheticDocument()) {
+        ChangeFullZoom(change);
+      } else {
+        ChangeTextSize(change);
+      }
+      nsContentUtils::DispatchChromeEvent(mDocument, static_cast<nsIDocument*>(mDocument),
+                                          NS_LITERAL_STRING("ZoomChangeUsingMouseWheel"),
+                                          true, true);
+    }
+}
+
+static nsIFrame*
+GetParentFrameToScroll(nsIFrame* aFrame)
+{
+  if (!aFrame)
+    return nullptr;
+
+  if (aFrame->StyleDisplay()->mPosition == NS_STYLE_POSITION_FIXED &&
+      nsLayoutUtils::IsReallyFixedPos(aFrame))
+    return aFrame->PresContext()->GetPresShell()->GetRootScrollFrame();
+
+  return aFrame->GetParent();
+}
+
+/*static*/ bool
+EventStateManager::CanVerticallyScrollFrameWithWheel(nsIFrame* aFrame)
+{
+  nsIContent* c = aFrame->GetContent();
+  if (!c) {
+    return true;
+  }
+  nsCOMPtr<nsITextControlElement> ctrl =
+    do_QueryInterface(c->IsInAnonymousSubtree() ? c->GetBindingParent() : c);
+  if (ctrl && ctrl->IsSingleLineTextControl()) {
+    return false;
+  }
+  return true;
+}
+
+void
+EventStateManager::DispatchLegacyMouseScrollEvents(nsIFrame* aTargetFrame,
+                                                   WidgetWheelEvent* aEvent,
+                                                   nsEventStatus* aStatus)
+{
+  MOZ_ASSERT(aEvent);
+  MOZ_ASSERT(aStatus);
+
+  if (!aTargetFrame || *aStatus == nsEventStatus_eConsumeNoDefault) {
+    return;
+  }
+
+  // Ignore mouse wheel transaction for computing legacy mouse wheel
+  // events' delta value.
+  nsIFrame* scrollFrame =
+    ComputeScrollTarget(aTargetFrame, aEvent,
+                        COMPUTE_LEGACY_MOUSE_SCROLL_EVENT_TARGET);
+
+  nsIScrollableFrame* scrollTarget = do_QueryFrame(scrollFrame);
+  nsPresContext* pc =
+    scrollFrame ? scrollFrame->PresContext() : aTargetFrame->PresContext();
+
+  // DOM event's delta vales are computed from CSS pixels.
+  nsSize scrollAmount = GetScrollAmount(pc, aEvent, scrollTarget);
+  nsIntSize scrollAmountInCSSPixels(
+    nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.width),
+    nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.height));
+
+  // XXX We don't deal with fractional amount in legacy event, though the
+  //     default action handler (DoScrollText()) deals with it.
+  //     If we implemented such strict computation, we would need additional
+  //     accumulated delta values. It would made the code more complicated.
+  //     And also it would computes different delta values from older version.
+  //     It doesn't make sense to implement such code for legacy events and
+  //     rare cases.
+  int32_t scrollDeltaX, scrollDeltaY, pixelDeltaX, pixelDeltaY;
+  switch (aEvent->mDeltaMode) {
+    case nsIDOMWheelEvent::DOM_DELTA_PAGE:
+      scrollDeltaX =
+        !aEvent->mLineOrPageDeltaX ? 0 :
+          (aEvent->mLineOrPageDeltaX > 0  ? nsIDOMUIEvent::SCROLL_PAGE_DOWN :
+                                            nsIDOMUIEvent::SCROLL_PAGE_UP);
+      scrollDeltaY =
+        !aEvent->mLineOrPageDeltaY ? 0 :
+          (aEvent->mLineOrPageDeltaY > 0  ? nsIDOMUIEvent::SCROLL_PAGE_DOWN :
+                                            nsIDOMUIEvent::SCROLL_PAGE_UP);
+      pixelDeltaX = RoundDown(aEvent->mDeltaX * scrollAmountInCSSPixels.width);
+      pixelDeltaY = RoundDown(aEvent->mDeltaY * scrollAmountInCSSPixels.height);
+      break;
+
+    case nsIDOMWheelEvent::DOM_DELTA_LINE:
+      scrollDeltaX = aEvent->mLineOrPageDeltaX;
+      scrollDeltaY = aEvent->mLineOrPageDeltaY;
+      pixelDeltaX = RoundDown(aEvent->mDeltaX * scrollAmountInCSSPixels.width);
+      pixelDeltaY = RoundDown(aEvent->mDeltaY * scrollAmountInCSSPixels.height);
+      break;
+
+    case nsIDOMWheelEvent::DOM_DELTA_PIXEL:
+      scrollDeltaX = aEvent->mLineOrPageDeltaX;
+      scrollDeltaY = aEvent->mLineOrPageDeltaY;
+      pixelDeltaX = RoundDown(aEvent->mDeltaX);
+      pixelDeltaY = RoundDown(aEvent->mDeltaY);
+      break;
+
+    default:
+      MOZ_CRASH("Invalid deltaMode value comes");
+  }
+
+  // Send the legacy events in following order:
+  // 1. Vertical scroll
+  // 2. Vertical pixel scroll (even if #1 isn't consumed)
+  // 3. Horizontal scroll (even if #1 and/or #2 are consumed)
+  // 4. Horizontal pixel scroll (even if #3 isn't consumed)
+
+  nsWeakFrame targetFrame(aTargetFrame);
+
+  MOZ_ASSERT(*aStatus != nsEventStatus_eConsumeNoDefault &&
+             !aEvent->DefaultPrevented(),
+             "If you make legacy events dispatched for default prevented wheel "
+             "event, you need to initialize stateX and stateY");
+  EventState stateX, stateY;
+  if (scrollDeltaY) {
+    SendLineScrollEvent(aTargetFrame, aEvent, stateY,
+                        scrollDeltaY, DELTA_DIRECTION_Y);
+    if (!targetFrame.IsAlive()) {
+      *aStatus = nsEventStatus_eConsumeNoDefault;
+      return;
+    }
+  }
+
+  if (pixelDeltaY) {
+    SendPixelScrollEvent(aTargetFrame, aEvent, stateY,
+                         pixelDeltaY, DELTA_DIRECTION_Y);
+    if (!targetFrame.IsAlive()) {
+      *aStatus = nsEventStatus_eConsumeNoDefault;
+      return;
+    }
+  }
+
+  if (scrollDeltaX) {
+    SendLineScrollEvent(aTargetFrame, aEvent, stateX,
+                        scrollDeltaX, DELTA_DIRECTION_X);
+    if (!targetFrame.IsAlive()) {
+      *aStatus = nsEventStatus_eConsumeNoDefault;
+      return;
+    }
+  }
+
+  if (pixelDeltaX) {
+    SendPixelScrollEvent(aTargetFrame, aEvent, stateX,
+                         pixelDeltaX, DELTA_DIRECTION_X);
+    if (!targetFrame.IsAlive()) {
+      *aStatus = nsEventStatus_eConsumeNoDefault;
+      return;
+    }
+  }
+
+  if (stateY.mDefaultPrevented) {
+    *aStatus = nsEventStatus_eConsumeNoDefault;
+    aEvent->PreventDefault(!stateY.mDefaultPreventedByContent);
+  }
+
+  if (stateX.mDefaultPrevented) {
+    *aStatus = nsEventStatus_eConsumeNoDefault;
+    aEvent->PreventDefault(!stateX.mDefaultPreventedByContent);
+  }
+}
+
+void
+EventStateManager::SendLineScrollEvent(nsIFrame* aTargetFrame,
+                                       WidgetWheelEvent* aEvent,
+                                       EventState& aState,
+                                       int32_t aDelta,
+                                       DeltaDirection aDeltaDirection)
+{
+  nsCOMPtr<nsIContent> targetContent = aTargetFrame->GetContent();
+  if (!targetContent)
+    targetContent = GetFocusedContent();
+  if (!targetContent)
+    return;
+
+  while (targetContent->IsNodeOfType(nsINode::eTEXT)) {
+    targetContent = targetContent->GetParent();
+  }
+
+  WidgetMouseScrollEvent event(aEvent->IsTrusted(),
+                               eLegacyMouseLineOrPageScroll, aEvent->mWidget);
+  event.mFlags.mDefaultPrevented = aState.mDefaultPrevented;
+  event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent;
+  event.mRefPoint = aEvent->mRefPoint;
+  event.mTime = aEvent->mTime;
+  event.mTimeStamp = aEvent->mTimeStamp;
+  event.mModifiers = aEvent->mModifiers;
+  event.buttons = aEvent->buttons;
+  event.mIsHorizontal = (aDeltaDirection == DELTA_DIRECTION_X);
+  event.mDelta = aDelta;
+  event.inputSource = aEvent->inputSource;
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+  EventDispatcher::Dispatch(targetContent, aTargetFrame->PresContext(),
+                            &event, nullptr, &status);
+  aState.mDefaultPrevented =
+    event.DefaultPrevented() || status == nsEventStatus_eConsumeNoDefault;
+  aState.mDefaultPreventedByContent = event.DefaultPreventedByContent();
+}
+
+void
+EventStateManager::SendPixelScrollEvent(nsIFrame* aTargetFrame,
+                                        WidgetWheelEvent* aEvent,
+                                        EventState& aState,
+                                        int32_t aPixelDelta,
+                                        DeltaDirection aDeltaDirection)
+{
+  nsCOMPtr<nsIContent> targetContent = aTargetFrame->GetContent();
+  if (!targetContent) {
+    targetContent = GetFocusedContent();
+    if (!targetContent)
+      return;
+  }
+
+  while (targetContent->IsNodeOfType(nsINode::eTEXT)) {
+    targetContent = targetContent->GetParent();
+  }
+
+  WidgetMouseScrollEvent event(aEvent->IsTrusted(),
+                               eLegacyMousePixelScroll, aEvent->mWidget);
+  event.mFlags.mDefaultPrevented = aState.mDefaultPrevented;
+  event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent;
+  event.mRefPoint = aEvent->mRefPoint;
+  event.mTime = aEvent->mTime;
+  event.mTimeStamp = aEvent->mTimeStamp;
+  event.mModifiers = aEvent->mModifiers;
+  event.buttons = aEvent->buttons;
+  event.mIsHorizontal = (aDeltaDirection == DELTA_DIRECTION_X);
+  event.mDelta = aPixelDelta;
+  event.inputSource = aEvent->inputSource;
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+  EventDispatcher::Dispatch(targetContent, aTargetFrame->PresContext(),
+                            &event, nullptr, &status);
+  aState.mDefaultPrevented =
+    event.DefaultPrevented() || status == nsEventStatus_eConsumeNoDefault;
+  aState.mDefaultPreventedByContent = event.DefaultPreventedByContent();
+}
+
+nsIFrame*
+EventStateManager::ComputeScrollTarget(nsIFrame* aTargetFrame,
+                                       WidgetWheelEvent* aEvent,
+                                       ComputeScrollTargetOptions aOptions)
+{
+  return ComputeScrollTarget(aTargetFrame, aEvent->mDeltaX, aEvent->mDeltaY,
+                             aEvent, aOptions);
+}
+
+// Overload ComputeScrollTarget method to allow passing "test" dx and dy when looking
+// for which scrollbarmediators to activate when two finger down on trackpad
+// and before any actual motion
+nsIFrame*
+EventStateManager::ComputeScrollTarget(nsIFrame* aTargetFrame,
+                                       double aDirectionX,
+                                       double aDirectionY,
+                                       WidgetWheelEvent* aEvent,
+                                       ComputeScrollTargetOptions aOptions)
+{
+  if ((aOptions & INCLUDE_PLUGIN_AS_TARGET) &&
+      !WheelPrefs::WheelEventsEnabledOnPlugins()) {
+    aOptions = RemovePluginFromTarget(aOptions);
+  }
+
+  if (aOptions & PREFER_MOUSE_WHEEL_TRANSACTION) {
+    // If the user recently scrolled with the mousewheel, then they probably
+    // want to scroll the same view as before instead of the view under the
+    // cursor.  WheelTransaction tracks the frame currently being
+    // scrolled with the mousewheel. We consider the transaction ended when the
+    // mouse moves more than "mousewheel.transaction.ignoremovedelay"
+    // milliseconds after the last scroll operation, or any time the mouse moves
+    // out of the frame, or when more than "mousewheel.transaction.timeout"
+    // milliseconds have passed after the last operation, even if the mouse
+    // hasn't moved.
+    nsIFrame* lastScrollFrame = WheelTransaction::GetTargetFrame();
+    if (lastScrollFrame) {
+      if (aOptions & INCLUDE_PLUGIN_AS_TARGET) {
+        nsPluginFrame* pluginFrame = do_QueryFrame(lastScrollFrame);
+        if (pluginFrame &&
+            pluginFrame->WantsToHandleWheelEventAsDefaultAction()) {
+          return lastScrollFrame;
+        }
+      }
+      nsIScrollableFrame* scrollableFrame =
+        lastScrollFrame->GetScrollTargetFrame();
+      if (scrollableFrame) {
+        nsIFrame* frameToScroll = do_QueryFrame(scrollableFrame);
+        MOZ_ASSERT(frameToScroll);
+        return frameToScroll;
+      }
+    }
+  }
+
+  // If the event doesn't cause scroll actually, we cannot find scroll target
+  // because we check if the event can cause scroll actually on each found
+  // scrollable frame.
+  if (!aDirectionX && !aDirectionY) {
+    return nullptr;
+  }
+
+  bool checkIfScrollableX =
+    aDirectionX && (aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS);
+  bool checkIfScrollableY =
+    aDirectionY && (aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS);
+
+  nsIFrame* scrollFrame =
+    !(aOptions & START_FROM_PARENT) ? aTargetFrame :
+                                      GetParentFrameToScroll(aTargetFrame);
+  for (; scrollFrame; scrollFrame = GetParentFrameToScroll(scrollFrame)) {
+    // Check whether the frame wants to provide us with a scrollable view.
+    nsIScrollableFrame* scrollableFrame = scrollFrame->GetScrollTargetFrame();
+    if (!scrollableFrame) {
+      // If the frame is a plugin frame, then, the plugin content may handle
+      // wheel events.  Only when the caller computes the scroll target for
+      // default action handling, we should assume the plugin frame as
+      // scrollable if the plugin wants to handle wheel events as default
+      // action.
+      if (aOptions & INCLUDE_PLUGIN_AS_TARGET) {
+        nsPluginFrame* pluginFrame = do_QueryFrame(scrollFrame);
+        if (pluginFrame &&
+            pluginFrame->WantsToHandleWheelEventAsDefaultAction()) {
+          return scrollFrame;
+        }
+      }
+      nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(scrollFrame);
+      if (menuPopupFrame) {
+        return nullptr;
+      }
+      continue;
+    }
+
+    nsIFrame* frameToScroll = do_QueryFrame(scrollableFrame);
+    MOZ_ASSERT(frameToScroll);
+
+    // Don't scroll vertically by mouse-wheel on a single-line text control.
+    if (checkIfScrollableY) {
+      if (!CanVerticallyScrollFrameWithWheel(scrollFrame)) {
+        continue;
+      }
+    }
+
+    if (!checkIfScrollableX && !checkIfScrollableY) {
+      return frameToScroll;
+    }
+
+    ScrollbarStyles ss = scrollableFrame->GetScrollbarStyles();
+    bool hiddenForV = (NS_STYLE_OVERFLOW_HIDDEN == ss.mVertical);
+    bool hiddenForH = (NS_STYLE_OVERFLOW_HIDDEN == ss.mHorizontal);
+    if ((hiddenForV && hiddenForH) ||
+        (checkIfScrollableY && !checkIfScrollableX && hiddenForV) ||
+        (checkIfScrollableX && !checkIfScrollableY && hiddenForH)) {
+      continue;
+    }
+
+    // For default action, we should climb up the tree if cannot scroll it
+    // by the event actually.
+    bool canScroll = WheelHandlingUtils::CanScrollOn(scrollableFrame,
+                                                     aDirectionX, aDirectionY);
+    // Comboboxes need special care.
+    nsIComboboxControlFrame* comboBox = do_QueryFrame(scrollFrame);
+    if (comboBox) {
+      if (comboBox->IsDroppedDown()) {
+        // Don't propagate to parent when drop down menu is active.
+        return canScroll ? frameToScroll : nullptr;
+      }
+      // Always propagate when not dropped down (even if focused).
+      continue;
+    }
+
+    if (canScroll) {
+      return frameToScroll;
+    }
+  }
+
+  nsIFrame* newFrame = nsLayoutUtils::GetCrossDocParentFrame(
+      aTargetFrame->PresContext()->FrameManager()->GetRootFrame());
+  aOptions =
+    static_cast<ComputeScrollTargetOptions>(aOptions & ~START_FROM_PARENT);
+  return newFrame ? ComputeScrollTarget(newFrame, aEvent, aOptions) : nullptr;
+}
+
+nsSize
+EventStateManager::GetScrollAmount(nsPresContext* aPresContext,
+                                   WidgetWheelEvent* aEvent,
+                                   nsIScrollableFrame* aScrollableFrame)
+{
+  MOZ_ASSERT(aPresContext);
+  MOZ_ASSERT(aEvent);
+
+  bool isPage = (aEvent->mDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PAGE);
+  if (aScrollableFrame) {
+    return isPage ? aScrollableFrame->GetPageScrollAmount() :
+                    aScrollableFrame->GetLineScrollAmount();
+  }
+
+  // If there is no scrollable frame and page scrolling, use view port size.
+  if (isPage) {
+    return aPresContext->GetVisibleArea().Size();
+  }
+
+  // If there is no scrollable frame, we should use root frame's information.
+  nsIFrame* rootFrame = aPresContext->PresShell()->GetRootFrame();
+  if (!rootFrame) {
+    return nsSize(0, 0);
+  }
+  RefPtr<nsFontMetrics> fm =
+    nsLayoutUtils::GetInflatedFontMetricsForFrame(rootFrame);
+  NS_ENSURE_TRUE(fm, nsSize(0, 0));
+  return nsSize(fm->AveCharWidth(), fm->MaxHeight());
+}
+
+void
+EventStateManager::DoScrollText(nsIScrollableFrame* aScrollableFrame,
+                                WidgetWheelEvent* aEvent)
+{
+  MOZ_ASSERT(aScrollableFrame);
+  MOZ_ASSERT(aEvent);
+
+  nsIFrame* scrollFrame = do_QueryFrame(aScrollableFrame);
+  MOZ_ASSERT(scrollFrame);
+
+  nsWeakFrame scrollFrameWeak(scrollFrame);
+  if (!WheelTransaction::WillHandleDefaultAction(aEvent, scrollFrameWeak)) {
+    return;
+  }
+
+  // Default action's actual scroll amount should be computed from device
+  // pixels.
+  nsPresContext* pc = scrollFrame->PresContext();
+  nsSize scrollAmount = GetScrollAmount(pc, aEvent, aScrollableFrame);
+  nsIntSize scrollAmountInDevPixels(
+    pc->AppUnitsToDevPixels(scrollAmount.width),
+    pc->AppUnitsToDevPixels(scrollAmount.height));
+  nsIntPoint actualDevPixelScrollAmount =
+    DeltaAccumulator::GetInstance()->
+      ComputeScrollAmountForDefaultAction(aEvent, scrollAmountInDevPixels);
+
+  // Don't scroll around the axis whose overflow style is hidden.
+  ScrollbarStyles overflowStyle = aScrollableFrame->GetScrollbarStyles();
+  if (overflowStyle.mHorizontal == NS_STYLE_OVERFLOW_HIDDEN) {
+    actualDevPixelScrollAmount.x = 0;
+  }
+  if (overflowStyle.mVertical == NS_STYLE_OVERFLOW_HIDDEN) {
+    actualDevPixelScrollAmount.y = 0;
+  }
+
+  nsIScrollbarMediator::ScrollSnapMode snapMode = nsIScrollbarMediator::DISABLE_SNAP;
+  nsIAtom* origin = nullptr;
+  switch (aEvent->mDeltaMode) {
+    case nsIDOMWheelEvent::DOM_DELTA_LINE:
+      origin = nsGkAtoms::mouseWheel;
+      snapMode = nsIScrollableFrame::ENABLE_SNAP;
+      break;
+    case nsIDOMWheelEvent::DOM_DELTA_PAGE:
+      origin = nsGkAtoms::pages;
+      snapMode = nsIScrollableFrame::ENABLE_SNAP;
+      break;
+    case nsIDOMWheelEvent::DOM_DELTA_PIXEL:
+      origin = nsGkAtoms::pixels;
+      break;
+    default:
+      MOZ_CRASH("Invalid deltaMode value comes");
+  }
+
+  // We shouldn't scroll more one page at once except when over one page scroll
+  // is allowed for the event.
+  nsSize pageSize = aScrollableFrame->GetPageScrollAmount();
+  nsIntSize devPixelPageSize(pc->AppUnitsToDevPixels(pageSize.width),
+                             pc->AppUnitsToDevPixels(pageSize.height));
+  if (!WheelPrefs::GetInstance()->IsOverOnePageScrollAllowedX(aEvent) &&
+      DeprecatedAbs(actualDevPixelScrollAmount.x) > devPixelPageSize.width) {
+    actualDevPixelScrollAmount.x =
+      (actualDevPixelScrollAmount.x >= 0) ? devPixelPageSize.width :
+                                            -devPixelPageSize.width;
+  }
+
+  if (!WheelPrefs::GetInstance()->IsOverOnePageScrollAllowedY(aEvent) &&
+      DeprecatedAbs(actualDevPixelScrollAmount.y) > devPixelPageSize.height) {
+    actualDevPixelScrollAmount.y =
+      (actualDevPixelScrollAmount.y >= 0) ? devPixelPageSize.height :
+                                            -devPixelPageSize.height;
+  }
+
+  bool isDeltaModePixel =
+    (aEvent->mDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PIXEL);
+
+  nsIScrollableFrame::ScrollMode mode;
+  switch (aEvent->mScrollType) {
+    case WidgetWheelEvent::SCROLL_DEFAULT:
+      if (isDeltaModePixel) {
+        mode = nsIScrollableFrame::NORMAL;
+      } else if (aEvent->mFlags.mHandledByAPZ) {
+        mode = nsIScrollableFrame::SMOOTH_MSD;
+      } else {
+        mode = nsIScrollableFrame::SMOOTH;
+      }
+      break;
+    case WidgetWheelEvent::SCROLL_SYNCHRONOUSLY:
+      mode = nsIScrollableFrame::INSTANT;
+      break;
+    case WidgetWheelEvent::SCROLL_ASYNCHRONOUSELY:
+      mode = nsIScrollableFrame::NORMAL;
+      break;
+    case WidgetWheelEvent::SCROLL_SMOOTHLY:
+      mode = nsIScrollableFrame::SMOOTH;
+      break;
+    default:
+      MOZ_CRASH("Invalid mScrollType value comes");
+  }
+
+  nsIScrollableFrame::ScrollMomentum momentum =
+    aEvent->mIsMomentum ? nsIScrollableFrame::SYNTHESIZED_MOMENTUM_EVENT
+                        : nsIScrollableFrame::NOT_MOMENTUM;
+
+  nsIntPoint overflow;
+  aScrollableFrame->ScrollBy(actualDevPixelScrollAmount,
+                             nsIScrollableFrame::DEVICE_PIXELS,
+                             mode, &overflow, origin, momentum, snapMode);
+
+  if (!scrollFrameWeak.IsAlive()) {
+    // If the scroll causes changing the layout, we can think that the event
+    // has been completely consumed by the content.  Then, users probably don't
+    // want additional action.
+    aEvent->mOverflowDeltaX = aEvent->mOverflowDeltaY = 0;
+  } else if (isDeltaModePixel) {
+    aEvent->mOverflowDeltaX = overflow.x;
+    aEvent->mOverflowDeltaY = overflow.y;
+  } else {
+    aEvent->mOverflowDeltaX =
+      static_cast<double>(overflow.x) / scrollAmountInDevPixels.width;
+    aEvent->mOverflowDeltaY =
+      static_cast<double>(overflow.y) / scrollAmountInDevPixels.height;
+  }
+
+  // If CSS overflow properties caused not to scroll, the overflowDelta* values
+  // should be same as delta* values since they may be used as gesture event by
+  // widget.  However, if there is another scrollable element in the ancestor
+  // along the axis, probably users don't want the operation to cause
+  // additional action such as moving history.  In such case, overflowDelta
+  // values should stay zero.
+  if (scrollFrameWeak.IsAlive()) {
+    if (aEvent->mDeltaX &&
+        overflowStyle.mHorizontal == NS_STYLE_OVERFLOW_HIDDEN &&
+        !ComputeScrollTarget(scrollFrame, aEvent,
+                             COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS)) {
+      aEvent->mOverflowDeltaX = aEvent->mDeltaX;
+    }
+    if (aEvent->mDeltaY &&
+        overflowStyle.mVertical == NS_STYLE_OVERFLOW_HIDDEN &&
+        !ComputeScrollTarget(scrollFrame, aEvent,
+                             COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS)) {
+      aEvent->mOverflowDeltaY = aEvent->mDeltaY;
+    }
+  }
+
+  NS_ASSERTION(aEvent->mOverflowDeltaX == 0 ||
+    (aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0),
+    "The sign of mOverflowDeltaX is different from the scroll direction");
+  NS_ASSERTION(aEvent->mOverflowDeltaY == 0 ||
+    (aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0),
+    "The sign of mOverflowDeltaY is different from the scroll direction");
+
+  WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta(aEvent);
+}
+
+void
+EventStateManager::DecideGestureEvent(WidgetGestureNotifyEvent* aEvent,
+                                      nsIFrame* targetFrame)
+{
+
+  NS_ASSERTION(aEvent->mMessage == eGestureNotify,
+               "DecideGestureEvent called with a non-gesture event");
+
+  /* Check the ancestor tree to decide if any frame is willing* to receive
+   * a MozPixelScroll event. If that's the case, the current touch gesture
+   * will be used as a pan gesture; otherwise it will be a regular
+   * mousedown/mousemove/click event.
+   *
+   * *willing: determine if it makes sense to pan the element using scroll events:
+   *  - For web content: if there are any visible scrollbars on the touch point
+   *  - For XUL: if it's an scrollable element that can currently scroll in some
+    *    direction.
+   *
+   * Note: we'll have to one-off various cases to ensure a good usable behavior
+   */
+  WidgetGestureNotifyEvent::PanDirection panDirection =
+    WidgetGestureNotifyEvent::ePanNone;
+  bool displayPanFeedback = false;
+  for (nsIFrame* current = targetFrame; current;
+       current = nsLayoutUtils::GetCrossDocParentFrame(current)) {
+
+    // e10s - mark remote content as pannable. This is a work around since
+    // we don't have access to remote frame scroll info here. Apz data may
+    // assist is solving this.
+    if (current && IsRemoteTarget(current->GetContent())) {
+      panDirection = WidgetGestureNotifyEvent::ePanBoth;
+      // We don't know when we reach bounds, so just disable feedback for now.
+      displayPanFeedback = false;
+      break;
+    }
+
+    nsIAtom* currentFrameType = current->GetType();
+
+    // Scrollbars should always be draggable
+    if (currentFrameType == nsGkAtoms::scrollbarFrame) {
+      panDirection = WidgetGestureNotifyEvent::ePanNone;
+      break;
+    }
+
+#ifdef MOZ_XUL
+    // Special check for trees
+    nsTreeBodyFrame* treeFrame = do_QueryFrame(current);
+    if (treeFrame) {
+      if (treeFrame->GetHorizontalOverflow()) {
+        panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
+      }
+      if (treeFrame->GetVerticalOverflow()) {
+        panDirection = WidgetGestureNotifyEvent::ePanVertical;
+      }
+      break;
+    }
+#endif
+
+    nsIScrollableFrame* scrollableFrame = do_QueryFrame(current);
+    if (scrollableFrame) {
+      if (current->IsFrameOfType(nsIFrame::eXULBox)) {
+        displayPanFeedback = true;
+
+        nsRect scrollRange = scrollableFrame->GetScrollRange();
+        bool canScrollHorizontally = scrollRange.width > 0;
+
+        if (targetFrame->GetType() == nsGkAtoms::menuFrame) {
+          // menu frames report horizontal scroll when they have submenus
+          // and we don't want that
+          canScrollHorizontally = false;
+          displayPanFeedback = false;
+        }
+
+        // Vertical panning has priority over horizontal panning, so
+        // when vertical movement is possible we can just finish the loop.
+        if (scrollRange.height > 0) {
+          panDirection = WidgetGestureNotifyEvent::ePanVertical;
+          break;
+        }
+
+        if (canScrollHorizontally) {
+          panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
+          displayPanFeedback = false;
+        }
+      } else { //Not a XUL box
+        uint32_t scrollbarVisibility = scrollableFrame->GetScrollbarVisibility();
+
+        //Check if we have visible scrollbars
+        if (scrollbarVisibility & nsIScrollableFrame::VERTICAL) {
+          panDirection = WidgetGestureNotifyEvent::ePanVertical;
+          displayPanFeedback = true;
+          break;
+        }
+
+        if (scrollbarVisibility & nsIScrollableFrame::HORIZONTAL) {
+          panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
+          displayPanFeedback = true;
+        }
+      }
+    } //scrollableFrame
+  } //ancestor chain
+  aEvent->mDisplayPanFeedback = displayPanFeedback;
+  aEvent->mPanDirection = panDirection;
+}
+
+#ifdef XP_MACOSX
+static bool
+NodeAllowsClickThrough(nsINode* aNode)
+{
+  while (aNode) {
+    if (aNode->IsXULElement()) {
+      mozilla::dom::Element* element = aNode->AsElement();
+      static nsIContent::AttrValuesArray strings[] =
+        {&nsGkAtoms::always, &nsGkAtoms::never, nullptr};
+      switch (element->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::clickthrough,
+                                       strings, eCaseMatters)) {
+        case 0:
+          return true;
+        case 1:
+          return false;
+      }
+    }
+    aNode = nsContentUtils::GetCrossDocParentNode(aNode);
+  }
+  return true;
+}
+#endif
+
+void
+EventStateManager::PostHandleKeyboardEvent(WidgetKeyboardEvent* aKeyboardEvent,
+                                           nsEventStatus& aStatus,
+                                           bool dispatchedToContentProcess)
+{
+  if (aStatus == nsEventStatus_eConsumeNoDefault ||
+      aKeyboardEvent->mInputMethodAppState == WidgetKeyboardEvent::eHandling) {
+    return;
+  }
+
+  // XXX Currently, our automated tests don't support mKeyNameIndex.
+  //     Therefore, we still need to handle this with keyCode.
+  switch(aKeyboardEvent->mKeyCode) {
+    case NS_VK_TAB:
+    case NS_VK_F6:
+      // This is to prevent keyboard scrolling while alt modifier in use.
+      if (!aKeyboardEvent->IsAlt()) {
+        aStatus = nsEventStatus_eConsumeNoDefault;
+
+        // Handling the tab event after it was sent to content is bad,
+        // because to the FocusManager the remote-browser looks like one
+        // element, so we would just move the focus to the next element
+        // in chrome, instead of handling it in content.
+        if (dispatchedToContentProcess)
+          break;
+
+        EnsureDocument(mPresContext);
+        nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+        if (fm && mDocument) {
+          // Shift focus forward or back depending on shift key
+          bool isDocMove =
+            aKeyboardEvent->IsControl() || aKeyboardEvent->mKeyCode == NS_VK_F6;
+          uint32_t dir = aKeyboardEvent->IsShift() ?
+            (isDocMove ? static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_BACKWARDDOC) :
+                         static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_BACKWARD)) :
+            (isDocMove ? static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_FORWARDDOC) :
+                         static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_FORWARD));
+          nsCOMPtr<nsIDOMElement> result;
+          fm->MoveFocus(mDocument->GetWindow(), nullptr, dir,
+                        nsIFocusManager::FLAG_BYKEY,
+                        getter_AddRefs(result));
+        }
+      }
+      return;
+    case 0:
+      // We handle keys with no specific keycode value below.
+      break;
+    default:
+      return;
+  }
+
+  switch(aKeyboardEvent->mKeyNameIndex) {
+    case KEY_NAME_INDEX_ZoomIn:
+    case KEY_NAME_INDEX_ZoomOut:
+      ChangeFullZoom(
+        aKeyboardEvent->mKeyNameIndex == KEY_NAME_INDEX_ZoomIn ? 1 : -1);
+      aStatus = nsEventStatus_eConsumeNoDefault;
+      break;
+    default:
+      break;
+  }
+}
+
+nsresult
+EventStateManager::PostHandleEvent(nsPresContext* aPresContext,
+                                   WidgetEvent* aEvent,
+                                   nsIFrame* aTargetFrame,
+                                   nsEventStatus* aStatus)
+{
+  NS_ENSURE_ARG(aPresContext);
+  NS_ENSURE_ARG_POINTER(aStatus);
+
+  mCurrentTarget = aTargetFrame;
+  mCurrentTargetContent = nullptr;
+
+  bool dispatchedToContentProcess = HandleCrossProcessEvent(aEvent, aStatus);
+  // NOTE: the above call may have destroyed aTargetFrame, please use
+  // mCurrentTarget henceforth.  This is to avoid using it accidentally:
+  aTargetFrame = nullptr;
+
+  // Most of the events we handle below require a frame.
+  // Add special cases here.
+  if (!mCurrentTarget && aEvent->mMessage != eMouseUp &&
+      aEvent->mMessage != eMouseDown) {
+    return NS_OK;
+  }
+
+  //Keep the prescontext alive, we might need it after event dispatch
+  RefPtr<nsPresContext> presContext = aPresContext;
+  nsresult ret = NS_OK;
+
+  switch (aEvent->mMessage) {
+  case eMouseDown:
+    {
+      WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+      if (mouseEvent->button == WidgetMouseEvent::eLeftButton &&
+          !sNormalLMouseEventInProcess) {
+        // We got a mouseup event while a mousedown event was being processed.
+        // Make sure that the capturing content is cleared.
+        nsIPresShell::SetCapturingContent(nullptr, 0);
+        break;
+      }
+
+      // For remote content, capture the event in the parent process at the
+      // <xul:browser remote> element. This will ensure that subsequent mousemove/mouseup
+      // events will continue to be dispatched to this element and therefore forwarded
+      // to the child.
+      if (dispatchedToContentProcess && !nsIPresShell::GetCapturingContent()) {
+        nsIContent* content = mCurrentTarget ? mCurrentTarget->GetContent() : nullptr;
+        nsIPresShell::SetCapturingContent(content, 0);
+      }
+
+      nsCOMPtr<nsIContent> activeContent;
+      if (nsEventStatus_eConsumeNoDefault != *aStatus) {
+        nsCOMPtr<nsIContent> newFocus;      
+        bool suppressBlur = false;
+        if (mCurrentTarget) {
+          mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(newFocus));
+          const nsStyleUserInterface* ui = mCurrentTarget->StyleUserInterface();
+          activeContent = mCurrentTarget->GetContent();
+
+          // In some cases, we do not want to even blur the current focused
+          // element. Those cases are:
+          // 1. -moz-user-focus CSS property is set to 'ignore';
+          // 2. Element with NS_EVENT_STATE_DISABLED
+          //    (aka :disabled pseudo-class for HTML element);
+          // 3. XUL control element has the disabled property set to 'true'.
+          //
+          // We can't use nsIFrame::IsFocusable() because we want to blur when
+          // we click on a visibility: none element.
+          // We can't use nsIContent::IsFocusable() because we want to blur when
+          // we click on a non-focusable element like a <div>.
+          // We have to use |aEvent->mTarget| to not make sure we do not check
+          // an anonymous node of the targeted element.
+          suppressBlur = (ui->mUserFocus == StyleUserFocus::Ignore);
+
+          if (!suppressBlur) {
+            nsCOMPtr<Element> element = do_QueryInterface(aEvent->mTarget);
+            suppressBlur = element &&
+                           element->State().HasState(NS_EVENT_STATE_DISABLED);
+          }
+
+          if (!suppressBlur) {
+            nsCOMPtr<nsIDOMXULControlElement> xulControl =
+              do_QueryInterface(aEvent->mTarget);
+            if (xulControl) {
+              bool disabled;
+              xulControl->GetDisabled(&disabled);
+              suppressBlur = disabled;
+            }
+          }
+        }
+
+        if (!suppressBlur) {
+          suppressBlur = nsContentUtils::IsUserFocusIgnored(activeContent);
+        }
+
+        nsIFrame* currFrame = mCurrentTarget;
+
+        // When a root content which isn't editable but has an editable HTML
+        // <body> element is clicked, we should redirect the focus to the
+        // the <body> element.  E.g., when an user click bottom of the editor
+        // where is outside of the <body> element, the <body> should be focused
+        // and the user can edit immediately after that.
+        //
+        // NOTE: The newFocus isn't editable that also means it's not in
+        // designMode.  In designMode, all contents are not focusable.
+        if (newFocus && !newFocus->IsEditable()) {
+          nsIDocument *doc = newFocus->GetComposedDoc();
+          if (doc && newFocus == doc->GetRootElement()) {
+            nsIContent *bodyContent =
+              nsLayoutUtils::GetEditableRootContentByContentEditable(doc);
+            if (bodyContent) {
+              nsIFrame* bodyFrame = bodyContent->GetPrimaryFrame();
+              if (bodyFrame) {
+                currFrame = bodyFrame;
+                newFocus = bodyContent;
+              }
+            }
+          }
+        }
+
+        // When the mouse is pressed, the default action is to focus the
+        // target. Look for the nearest enclosing focusable frame.
+        while (currFrame) {
+          // If the mousedown happened inside a popup, don't
+          // try to set focus on one of its containing elements
+          const nsStyleDisplay* display = currFrame->StyleDisplay();
+          if (display->mDisplay == StyleDisplay::Popup) {
+            newFocus = nullptr;
+            break;
+          }
+
+          int32_t tabIndexUnused;
+          if (currFrame->IsFocusable(&tabIndexUnused, true)) {
+            newFocus = currFrame->GetContent();
+            nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(newFocus));
+            if (domElement)
+              break;
+          }
+          currFrame = currFrame->GetParent();
+        }
+
+        nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+        if (fm) {
+          // if something was found to focus, focus it. Otherwise, if the
+          // element that was clicked doesn't have -moz-user-focus: ignore,
+          // clear the existing focus. For -moz-user-focus: ignore, the focus
+          // is just left as is.
+          // Another effect of mouse clicking, handled in nsSelection, is that
+          // it should update the caret position to where the mouse was
+          // clicked. Because the focus is cleared when clicking on a
+          // non-focusable node, the next press of the tab key will cause
+          // focus to be shifted from the caret position instead of the root.
+          if (newFocus && currFrame) {
+            // use the mouse flag and the noscroll flag so that the content
+            // doesn't unexpectedly scroll when clicking an element that is
+            // only half visible
+            uint32_t flags = nsIFocusManager::FLAG_BYMOUSE |
+                             nsIFocusManager::FLAG_NOSCROLL;
+            // If this was a touch-generated event, pass that information:
+            if (mouseEvent->inputSource == nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) {
+              flags |= nsIFocusManager::FLAG_BYTOUCH;
+            }
+            nsCOMPtr<nsIDOMElement> newFocusElement = do_QueryInterface(newFocus);
+            fm->SetFocus(newFocusElement, flags);
+          }
+          else if (!suppressBlur) {
+            // clear the focus within the frame and then set it as the
+            // focused frame
+            EnsureDocument(mPresContext);
+            if (mDocument) {
+#ifdef XP_MACOSX
+              if (!activeContent || !activeContent->IsXULElement())
+#endif
+                fm->ClearFocus(mDocument->GetWindow());
+              fm->SetFocusedWindow(mDocument->GetWindow());
+            }
+          }
+        }
+
+        // The rest is left button-specific.
+        if (mouseEvent->button != WidgetMouseEvent::eLeftButton) {
+          break;
+        }
+
+        if (activeContent) {
+          // The nearest enclosing element goes into the
+          // :active state.  If we fail the QI to DOMElement,
+          // then we know we're only a node, and that we need
+          // to obtain our parent element and put it into :active
+          // instead.
+          nsCOMPtr<nsIDOMElement> elt(do_QueryInterface(activeContent));
+          if (!elt) {
+            nsIContent* par = activeContent->GetParent();
+            if (par)
+              activeContent = par;
+          }
+        }
+      }
+      else {
+        // if we're here, the event handler returned false, so stop
+        // any of our own processing of a drag. Workaround for bug 43258.
+        StopTrackingDragGesture();
+
+        // When the event was cancelled, there is currently a chrome document
+        // focused and a mousedown just occurred on a content document, ensure
+        // that the window that was clicked is focused.
+        EnsureDocument(mPresContext);
+        nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+        if (mDocument && fm) {
+          nsCOMPtr<mozIDOMWindowProxy> window;
+          fm->GetFocusedWindow(getter_AddRefs(window));
+          auto* currentWindow = nsPIDOMWindowOuter::From(window);
+          if (currentWindow && mDocument->GetWindow() &&
+              currentWindow != mDocument->GetWindow() &&
+              !nsContentUtils::IsChromeDoc(mDocument)) {
+            nsCOMPtr<nsPIDOMWindowOuter> currentTop;
+            nsCOMPtr<nsPIDOMWindowOuter> newTop;
+            currentTop = currentWindow->GetTop();
+            newTop = mDocument->GetWindow()->GetTop();
+            nsCOMPtr<nsIDocument> currentDoc = currentWindow->GetExtantDoc();
+            if (nsContentUtils::IsChromeDoc(currentDoc) ||
+                (currentTop && newTop && currentTop != newTop)) {
+              fm->SetFocusedWindow(mDocument->GetWindow());
+            }
+          }
+        }
+      }
+      SetActiveManager(this, activeContent);
+    }
+    break;
+  case ePointerCancel: {
+    if(WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent()) {
+      GenerateMouseEnterExit(mouseEvent);
+    }
+    // After firing the pointercancel event, a user agent must also fire a
+    // pointerout event followed by a pointerleave event.
+    MOZ_FALLTHROUGH;
+  }
+  case ePointerUp: {
+    WidgetPointerEvent* pointerEvent = aEvent->AsPointerEvent();
+    // After UP/Cancel Touch pointers become invalid so we can remove relevant helper from Table
+    // Mouse/Pen pointers are valid all the time (not only between down/up)
+    if (pointerEvent->inputSource == nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) {
+      mPointersEnterLeaveHelper.Remove(pointerEvent->pointerId);
+      GenerateMouseEnterExit(pointerEvent);
+    }
+    break;
+  }
+  case eMouseUp:
+    {
+      ClearGlobalActiveContent(this);
+      WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+      if (mouseEvent && mouseEvent->IsReal()) {
+        if (!mCurrentTarget) {
+          GetEventTarget();
+        }
+        // Make sure to dispatch the click even if there is no frame for
+        // the current target element. This is required for Web compatibility.
+        ret = CheckForAndDispatchClick(mouseEvent, aStatus);
+      }
+
+      nsIPresShell *shell = presContext->GetPresShell();
+      if (shell) {
+        RefPtr<nsFrameSelection> frameSelection = shell->FrameSelection();
+        frameSelection->SetDragState(false);
+      }
+    }
+    break;
+  case eWheelOperationEnd:
+    {
+      MOZ_ASSERT(aEvent->IsTrusted());
+      ScrollbarsForWheel::MayInactivate();
+      WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
+      nsIScrollableFrame* scrollTarget =
+        do_QueryFrame(ComputeScrollTarget(mCurrentTarget, wheelEvent,
+                                          COMPUTE_DEFAULT_ACTION_TARGET));
+      if (scrollTarget) {
+        scrollTarget->ScrollSnap();
+      }
+    }
+    break;
+  case eWheel:
+  case eWheelOperationStart:
+    {
+      MOZ_ASSERT(aEvent->IsTrusted());
+
+      if (*aStatus == nsEventStatus_eConsumeNoDefault) {
+        ScrollbarsForWheel::Inactivate();
+        break;
+      }
+
+      WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
+
+      // Check if the frame to scroll before checking the default action
+      // because if the scroll target is a plugin, the default action should be
+      // chosen by the plugin rather than by our prefs.
+      nsIFrame* frameToScroll =
+        ComputeScrollTarget(mCurrentTarget, wheelEvent,
+                            COMPUTE_DEFAULT_ACTION_TARGET);
+      nsPluginFrame* pluginFrame = do_QueryFrame(frameToScroll);
+
+      // When APZ is enabled, the actual scroll animation might be handled by
+      // the compositor.
+      WheelPrefs::Action action;
+      if (pluginFrame) {
+        MOZ_ASSERT(pluginFrame->WantsToHandleWheelEventAsDefaultAction());
+        action = WheelPrefs::ACTION_SEND_TO_PLUGIN;
+      } else if (wheelEvent->mFlags.mHandledByAPZ) {
+        action = WheelPrefs::ACTION_NONE;
+      } else {
+        action = WheelPrefs::GetInstance()->ComputeActionFor(wheelEvent);
+      }
+      switch (action) {
+        case WheelPrefs::ACTION_SCROLL: {
+          // For scrolling of default action, we should honor the mouse wheel
+          // transaction.
+
+          ScrollbarsForWheel::PrepareToScrollText(this, mCurrentTarget, wheelEvent);
+
+          if (aEvent->mMessage != eWheel ||
+              (!wheelEvent->mDeltaX && !wheelEvent->mDeltaY)) {
+            break;
+          }
+
+          nsIScrollableFrame* scrollTarget = do_QueryFrame(frameToScroll);
+          ScrollbarsForWheel::SetActiveScrollTarget(scrollTarget);
+
+          nsIFrame* rootScrollFrame = !mCurrentTarget ? nullptr :
+            mCurrentTarget->PresContext()->PresShell()->GetRootScrollFrame();
+          nsIScrollableFrame* rootScrollableFrame = nullptr;
+          if (rootScrollFrame) {
+            rootScrollableFrame = do_QueryFrame(rootScrollFrame);
+          }
+          if (!scrollTarget || scrollTarget == rootScrollableFrame) {
+            wheelEvent->mViewPortIsOverscrolled = true;
+          }
+          wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX;
+          wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY;
+          WheelPrefs::GetInstance()->
+            CancelApplyingUserPrefsFromOverflowDelta(wheelEvent);
+          if (scrollTarget) {
+            DoScrollText(scrollTarget, wheelEvent);
+          } else {
+            WheelTransaction::EndTransaction();
+            ScrollbarsForWheel::Inactivate();
+          }
+          break;
+        }
+        case WheelPrefs::ACTION_HISTORY: {
+          // If this event doesn't cause eLegacyMouseLineOrPageScroll event or
+          // the direction is oblique, don't perform history back/forward.
+          int32_t intDelta = wheelEvent->GetPreferredIntDelta();
+          if (!intDelta) {
+            break;
+          }
+          DoScrollHistory(intDelta);
+          break;
+        }
+        case WheelPrefs::ACTION_ZOOM: {
+          // If this event doesn't cause eLegacyMouseLineOrPageScroll event or
+          // the direction is oblique, don't perform zoom in/out.
+          int32_t intDelta = wheelEvent->GetPreferredIntDelta();
+          if (!intDelta) {
+            break;
+          }
+          DoScrollZoom(mCurrentTarget, intDelta);
+          break;
+        }
+        case WheelPrefs::ACTION_SEND_TO_PLUGIN:
+          MOZ_ASSERT(pluginFrame);
+
+          if (wheelEvent->mMessage != eWheel ||
+              (!wheelEvent->mDeltaX && !wheelEvent->mDeltaY)) {
+            break;
+          }
+
+          MOZ_ASSERT(static_cast<void*>(frameToScroll) ==
+                       static_cast<void*>(pluginFrame));
+          if (!WheelTransaction::WillHandleDefaultAction(wheelEvent,
+                                                         frameToScroll)) {
+            break;
+          }
+
+          pluginFrame->HandleWheelEventAsDefaultAction(wheelEvent);
+          break;
+        case WheelPrefs::ACTION_NONE:
+        default:
+          bool allDeltaOverflown = false;
+          if (wheelEvent->mFlags.mHandledByAPZ) {
+            if (wheelEvent->mCanTriggerSwipe) {
+              // For events that can trigger swipes, APZ needs to know whether
+              // scrolling is possible in the requested direction. It does this
+              // by looking at the scroll overflow values on mCanTriggerSwipe
+              // events after they have been processed.
+              allDeltaOverflown =
+                !ComputeScrollTarget(mCurrentTarget, wheelEvent,
+                                     COMPUTE_DEFAULT_ACTION_TARGET);
+            }
+          } else {
+            // The event was processed neither by APZ nor by us, so all of the
+            // delta values must be overflown delta values.
+            allDeltaOverflown = true;
+          }
+
+          if (!allDeltaOverflown) {
+            break;
+          }
+          wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX;
+          wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY;
+          WheelPrefs::GetInstance()->
+            CancelApplyingUserPrefsFromOverflowDelta(wheelEvent);
+          wheelEvent->mViewPortIsOverscrolled = true;
+          break;
+      }
+      *aStatus = nsEventStatus_eConsumeNoDefault;
+    }
+    break;
+
+  case eGestureNotify:
+    {
+      if (nsEventStatus_eConsumeNoDefault != *aStatus) {
+        DecideGestureEvent(aEvent->AsGestureNotifyEvent(), mCurrentTarget);
+      }
+    }
+    break;
+
+  case eDragEnter:
+  case eDragOver:
+    {
+      NS_ASSERTION(aEvent->mClass == eDragEventClass, "Expected a drag event");
+
+      nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+      if (!dragSession)
+        break;
+
+      // Reset the flag.
+      dragSession->SetOnlyChromeDrop(false);
+      if (mPresContext) {
+        EnsureDocument(mPresContext);
+      }
+      bool isChromeDoc = nsContentUtils::IsChromeDoc(mDocument);
+
+      // the initial dataTransfer is the one from the dragstart event that
+      // was set on the dragSession when the drag began.
+      nsCOMPtr<nsIDOMDataTransfer> dataTransfer;
+      nsCOMPtr<nsIDOMDataTransfer> initialDataTransfer;
+      dragSession->GetDataTransfer(getter_AddRefs(initialDataTransfer));
+
+      WidgetDragEvent *dragEvent = aEvent->AsDragEvent();
+
+      // collect any changes to moz cursor settings stored in the event's
+      // data transfer.
+      UpdateDragDataTransfer(dragEvent);
+
+      // cancelling a dragenter or dragover event means that a drop should be
+      // allowed, so update the dropEffect and the canDrop state to indicate
+      // that a drag is allowed. If the event isn't cancelled, a drop won't be
+      // allowed. Essentially, to allow a drop somewhere, specify the effects
+      // using the effectAllowed and dropEffect properties in a dragenter or
+      // dragover event and cancel the event. To not allow a drop somewhere,
+      // don't cancel the event or set the effectAllowed or dropEffect to
+      // "none". This way, if the event is just ignored, no drop will be
+      // allowed.
+      uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
+      uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE;
+      if (nsEventStatus_eConsumeNoDefault == *aStatus) {
+        // if the event has a dataTransfer set, use it.
+        if (dragEvent->mDataTransfer) {
+          // get the dataTransfer and the dropEffect that was set on it
+          dataTransfer = do_QueryInterface(dragEvent->mDataTransfer);
+          dataTransfer->GetDropEffectInt(&dropEffect);
+        }
+        else {
+          // if dragEvent->mDataTransfer is null, it means that no attempt was
+          // made to access the dataTransfer during the event, yet the event
+          // was cancelled. Instead, use the initial data transfer available
+          // from the drag session. The drop effect would not have been
+          // initialized (which is done in DragEvent::GetDataTransfer),
+          // so set it from the drag action. We'll still want to filter it
+          // based on the effectAllowed below.
+          dataTransfer = initialDataTransfer;
+
+          dragSession->GetDragAction(&action);
+
+          // filter the drop effect based on the action. Use UNINITIALIZED as
+          // any effect is allowed.
+          dropEffect = nsContentUtils::FilterDropEffect(action,
+                         nsIDragService::DRAGDROP_ACTION_UNINITIALIZED);
+        }
+
+        // At this point, if the dataTransfer is null, it means that the
+        // drag was originally started by directly calling the drag service.
+        // Just assume that all effects are allowed.
+        uint32_t effectAllowed = nsIDragService::DRAGDROP_ACTION_UNINITIALIZED;
+        if (dataTransfer)
+          dataTransfer->GetEffectAllowedInt(&effectAllowed);
+
+        // set the drag action based on the drop effect and effect allowed.
+        // The drop effect field on the drag transfer object specifies the
+        // desired current drop effect. However, it cannot be used if the
+        // effectAllowed state doesn't include that type of action. If the
+        // dropEffect is "none", then the action will be 'none' so a drop will
+        // not be allowed.
+        if (effectAllowed == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED ||
+            dropEffect & effectAllowed)
+          action = dropEffect;
+
+        if (action == nsIDragService::DRAGDROP_ACTION_NONE)
+          dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
+
+        // inform the drag session that a drop is allowed on this node.
+        dragSession->SetDragAction(action);
+        dragSession->SetCanDrop(action != nsIDragService::DRAGDROP_ACTION_NONE);
+
+        // For now, do this only for dragover.
+        //XXXsmaug dragenter needs some more work.
+        if (aEvent->mMessage == eDragOver && !isChromeDoc) {
+          // Someone has called preventDefault(), check whether is was on
+          // content or chrome.
+          dragSession->SetOnlyChromeDrop(
+            !dragEvent->mDefaultPreventedOnContent);
+        }
+      } else if (aEvent->mMessage == eDragOver && !isChromeDoc) {
+        // No one called preventDefault(), so handle drop only in chrome.
+        dragSession->SetOnlyChromeDrop(true);
+      }
+      if (ContentChild* child = ContentChild::GetSingleton()) {
+        child->SendUpdateDropEffect(action, dropEffect);
+      }
+      if (dispatchedToContentProcess) {
+        dragSession->SetCanDrop(true);
+      } else if (initialDataTransfer) {
+        // Now set the drop effect in the initial dataTransfer. This ensures
+        // that we can get the desired drop effect in the drop event. For events
+        // dispatched to content, the content process will take care of setting
+        // this.
+        initialDataTransfer->SetDropEffectInt(dropEffect);
+      }
+    }
+    break;
+
+  case eDrop:
+    {
+      sLastDragOverFrame = nullptr;
+      ClearGlobalActiveContent(this);
+      break;
+    }
+  case eDragExit:
+     // make sure to fire the enter and exit_synth events after the
+     // eDragExit event, otherwise we'll clean up too early
+    GenerateDragDropEnterExit(presContext, aEvent->AsDragEvent());
+    break;
+
+  case eBeforeKeyUp:
+  case eKeyUp:
+  case eAfterKeyUp:
+    break;
+
+  case eKeyPress:
+    {
+      WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
+      PostHandleKeyboardEvent(keyEvent, *aStatus, dispatchedToContentProcess);
+    }
+    break;
+
+  case eMouseEnterIntoWidget:
+    if (mCurrentTarget) {
+      nsCOMPtr<nsIContent> targetContent;
+      mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent));
+      SetContentState(targetContent, NS_EVENT_STATE_HOVER);
+    }
+    break;
+
+#ifdef XP_MACOSX
+  case eMouseActivate:
+    if (mCurrentTarget) {
+      nsCOMPtr<nsIContent> targetContent;
+      mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent));
+      if (!NodeAllowsClickThrough(targetContent)) {
+        *aStatus = nsEventStatus_eConsumeNoDefault;
+      }
+    }
+    break;
+#endif
+
+  default:
+    break;
+  }
+
+  //Reset target frame to null to avoid mistargeting after reentrant event
+  mCurrentTarget = nullptr;
+  mCurrentTargetContent = nullptr;
+
+  return ret;
+}
+
+TabParent*
+EventStateManager::GetCrossProcessTarget()
+{
+  return IMEStateManager::GetActiveTabParent();
+}
+
+bool
+EventStateManager::IsTargetCrossProcess(WidgetGUIEvent* aEvent)
+{
+  // Check to see if there is a focused, editable content in chrome,
+  // in that case, do not forward IME events to content
+  nsIContent *focusedContent = GetFocusedContent();
+  if (focusedContent && focusedContent->IsEditable())
+    return false;
+  return IMEStateManager::GetActiveTabParent() != nullptr;
+}
+
+void
+EventStateManager::NotifyDestroyPresContext(nsPresContext* aPresContext)
+{
+  IMEStateManager::OnDestroyPresContext(aPresContext);
+  if (mHoverContent) {
+    // Bug 70855: Presentation is going away, possibly for a reframe.
+    // Reset the hover state so that if we're recreating the presentation,
+    // we won't have the old hover state still set in the new presentation,
+    // as if the new presentation is resized, a new element may be hovered. 
+    SetContentState(nullptr, NS_EVENT_STATE_HOVER);
+  }
+  mPointersEnterLeaveHelper.Clear();
+}
+
+void
+EventStateManager::SetPresContext(nsPresContext* aPresContext)
+{
+  mPresContext = aPresContext;
+}
+
+void
+EventStateManager::ClearFrameRefs(nsIFrame* aFrame)
+{
+  if (aFrame && aFrame == mCurrentTarget) {
+    mCurrentTargetContent = aFrame->GetContent();
+  }
+}
+
+void
+EventStateManager::UpdateCursor(nsPresContext* aPresContext,
+                                WidgetEvent* aEvent,
+                                nsIFrame* aTargetFrame,
+                                nsEventStatus* aStatus)
+{
+  if (aTargetFrame && IsRemoteTarget(aTargetFrame->GetContent())) {
+    return;
+  }
+
+  int32_t cursor = NS_STYLE_CURSOR_DEFAULT;
+  imgIContainer* container = nullptr;
+  bool haveHotspot = false;
+  float hotspotX = 0.0f, hotspotY = 0.0f;
+
+  //If cursor is locked just use the locked one
+  if (mLockCursor) {
+    cursor = mLockCursor;
+  }
+  //If not locked, look for correct cursor
+  else if (aTargetFrame) {
+    nsIFrame::Cursor framecursor;
+    nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent,
+                                                              aTargetFrame);
+    // Avoid setting cursor when the mouse is over a windowless pluign.
+    if (NS_FAILED(aTargetFrame->GetCursor(pt, framecursor))) {
+      if (XRE_IsContentProcess()) {
+        mLastFrameConsumedSetCursor = true;
+      }
+      return;
+    }
+    // Make sure cursors get reset after the mouse leaves a
+    // windowless plugin frame.
+    if (mLastFrameConsumedSetCursor) {
+      ClearCachedWidgetCursor(aTargetFrame);
+      mLastFrameConsumedSetCursor = false;
+    }
+    // If the current cursor is from the same frame, and it is now
+    // loading some new image for the cursor, we should wait for a
+    // while rather than taking its fallback cursor directly.
+    if (framecursor.mLoading &&
+        gLastCursorSourceFrame == aTargetFrame &&
+        TimeStamp::NowLoRes() - gLastCursorUpdateTime <
+          TimeDuration::FromMilliseconds(kCursorLoadingTimeout)) {
+      return;
+    }
+    cursor = framecursor.mCursor;
+    container = framecursor.mContainer;
+    haveHotspot = framecursor.mHaveHotspot;
+    hotspotX = framecursor.mHotspotX;
+    hotspotY = framecursor.mHotspotY;
+  }
+
+  if (nsContentUtils::UseActivityCursor()) {
+    // Check whether or not to show the busy cursor
+    nsCOMPtr<nsIDocShell> docShell(aPresContext->GetDocShell());
+    if (!docShell) return;
+    uint32_t busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
+    docShell->GetBusyFlags(&busyFlags);
+
+    // Show busy cursor everywhere before page loads
+    // and just replace the arrow cursor after page starts loading
+    if (busyFlags & nsIDocShell::BUSY_FLAGS_BUSY &&
+          (cursor == NS_STYLE_CURSOR_AUTO || cursor == NS_STYLE_CURSOR_DEFAULT))
+    {
+      cursor = NS_STYLE_CURSOR_SPINNING;
+      container = nullptr;
+    }
+  }
+
+  if (aTargetFrame) {
+    SetCursor(cursor, container, haveHotspot, hotspotX, hotspotY,
+              aTargetFrame->GetNearestWidget(), false);
+    gLastCursorSourceFrame = aTargetFrame;
+    gLastCursorUpdateTime = TimeStamp::NowLoRes();
+  }
+
+  if (mLockCursor || NS_STYLE_CURSOR_AUTO != cursor) {
+    *aStatus = nsEventStatus_eConsumeDoDefault;
+  }
+}
+
+void
+EventStateManager::ClearCachedWidgetCursor(nsIFrame* aTargetFrame)
+{
+  if (!aTargetFrame) {
+    return;
+  }
+  nsIWidget* aWidget = aTargetFrame->GetNearestWidget();
+  if (!aWidget) {
+    return;
+  }
+  aWidget->ClearCachedCursor();
+}
+
+nsresult
+EventStateManager::SetCursor(int32_t aCursor, imgIContainer* aContainer,
+                             bool aHaveHotspot,
+                             float aHotspotX, float aHotspotY,
+                             nsIWidget* aWidget, bool aLockCursor)
+{
+  EnsureDocument(mPresContext);
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE);
+  sMouseOverDocument = mDocument.get();
+
+  nsCursor c;
+
+  NS_ENSURE_TRUE(aWidget, NS_ERROR_FAILURE);
+  if (aLockCursor) {
+    if (NS_STYLE_CURSOR_AUTO != aCursor) {
+      mLockCursor = aCursor;
+    }
+    else {
+      //If cursor style is set to auto we unlock the cursor again.
+      mLockCursor = 0;
+    }
+  }
+  switch (aCursor) {
+  default:
+  case NS_STYLE_CURSOR_AUTO:
+  case NS_STYLE_CURSOR_DEFAULT:
+    c = eCursor_standard;
+    break;
+  case NS_STYLE_CURSOR_POINTER:
+    c = eCursor_hyperlink;
+    break;
+  case NS_STYLE_CURSOR_CROSSHAIR:
+    c = eCursor_crosshair;
+    break;
+  case NS_STYLE_CURSOR_MOVE:
+    c = eCursor_move;
+    break;
+  case NS_STYLE_CURSOR_TEXT:
+    c = eCursor_select;
+    break;
+  case NS_STYLE_CURSOR_WAIT:
+    c = eCursor_wait;
+    break;
+  case NS_STYLE_CURSOR_HELP:
+    c = eCursor_help;
+    break;
+  case NS_STYLE_CURSOR_N_RESIZE:
+    c = eCursor_n_resize;
+    break;
+  case NS_STYLE_CURSOR_S_RESIZE:
+    c = eCursor_s_resize;
+    break;
+  case NS_STYLE_CURSOR_W_RESIZE:
+    c = eCursor_w_resize;
+    break;
+  case NS_STYLE_CURSOR_E_RESIZE:
+    c = eCursor_e_resize;
+    break;
+  case NS_STYLE_CURSOR_NW_RESIZE:
+    c = eCursor_nw_resize;
+    break;
+  case NS_STYLE_CURSOR_SE_RESIZE:
+    c = eCursor_se_resize;
+    break;
+  case NS_STYLE_CURSOR_NE_RESIZE:
+    c = eCursor_ne_resize;
+    break;
+  case NS_STYLE_CURSOR_SW_RESIZE:
+    c = eCursor_sw_resize;
+    break;
+  case NS_STYLE_CURSOR_COPY: // CSS3
+    c = eCursor_copy;
+    break;
+  case NS_STYLE_CURSOR_ALIAS:
+    c = eCursor_alias;
+    break;
+  case NS_STYLE_CURSOR_CONTEXT_MENU:
+    c = eCursor_context_menu;
+    break;
+  case NS_STYLE_CURSOR_CELL:
+    c = eCursor_cell;
+    break;
+  case NS_STYLE_CURSOR_GRAB:
+    c = eCursor_grab;
+    break;
+  case NS_STYLE_CURSOR_GRABBING:
+    c = eCursor_grabbing;
+    break;
+  case NS_STYLE_CURSOR_SPINNING:
+    c = eCursor_spinning;
+    break;
+  case NS_STYLE_CURSOR_ZOOM_IN:
+    c = eCursor_zoom_in;
+    break;
+  case NS_STYLE_CURSOR_ZOOM_OUT:
+    c = eCursor_zoom_out;
+    break;
+  case NS_STYLE_CURSOR_NOT_ALLOWED:
+    c = eCursor_not_allowed;
+    break;
+  case NS_STYLE_CURSOR_COL_RESIZE:
+    c = eCursor_col_resize;
+    break;
+  case NS_STYLE_CURSOR_ROW_RESIZE:
+    c = eCursor_row_resize;
+    break;
+  case NS_STYLE_CURSOR_NO_DROP:
+    c = eCursor_no_drop;
+    break;
+  case NS_STYLE_CURSOR_VERTICAL_TEXT:
+    c = eCursor_vertical_text;
+    break;
+  case NS_STYLE_CURSOR_ALL_SCROLL:
+    c = eCursor_all_scroll;
+    break;
+  case NS_STYLE_CURSOR_NESW_RESIZE:
+    c = eCursor_nesw_resize;
+    break;
+  case NS_STYLE_CURSOR_NWSE_RESIZE:
+    c = eCursor_nwse_resize;
+    break;
+  case NS_STYLE_CURSOR_NS_RESIZE:
+    c = eCursor_ns_resize;
+    break;
+  case NS_STYLE_CURSOR_EW_RESIZE:
+    c = eCursor_ew_resize;
+    break;
+  case NS_STYLE_CURSOR_NONE:
+    c = eCursor_none;
+    break;
+  }
+
+  // First, try the imgIContainer, if non-null
+  nsresult rv = NS_ERROR_FAILURE;
+  if (aContainer) {
+    uint32_t hotspotX, hotspotY;
+
+    // css3-ui says to use the CSS-specified hotspot if present,
+    // otherwise use the intrinsic hotspot, otherwise use the top left
+    // corner.
+    if (aHaveHotspot) {
+      int32_t imgWidth, imgHeight;
+      aContainer->GetWidth(&imgWidth);
+      aContainer->GetHeight(&imgHeight);
+
+      // XXX std::max(NS_lround(x), 0)?
+      hotspotX = aHotspotX > 0.0f
+                   ? uint32_t(aHotspotX + 0.5f) : uint32_t(0);
+      if (hotspotX >= uint32_t(imgWidth))
+        hotspotX = imgWidth - 1;
+      hotspotY = aHotspotY > 0.0f
+                   ? uint32_t(aHotspotY + 0.5f) : uint32_t(0);
+      if (hotspotY >= uint32_t(imgHeight))
+        hotspotY = imgHeight - 1;
+    } else {
+      hotspotX = 0;
+      hotspotY = 0;
+      nsCOMPtr<nsIProperties> props(do_QueryInterface(aContainer));
+      if (props) {
+        nsCOMPtr<nsISupportsPRUint32> hotspotXWrap, hotspotYWrap;
+
+        props->Get("hotspotX", NS_GET_IID(nsISupportsPRUint32), getter_AddRefs(hotspotXWrap));
+        props->Get("hotspotY", NS_GET_IID(nsISupportsPRUint32), getter_AddRefs(hotspotYWrap));
+
+        if (hotspotXWrap)
+          hotspotXWrap->GetData(&hotspotX);
+        if (hotspotYWrap)
+          hotspotYWrap->GetData(&hotspotY);
+      }
+    }
+
+    rv = aWidget->SetCursor(aContainer, hotspotX, hotspotY);
+  }
+
+  if (NS_FAILED(rv))
+    aWidget->SetCursor(c);
+
+  return NS_OK;
+}
+
+class MOZ_STACK_CLASS ESMEventCB : public EventDispatchingCallback
+{
+public:
+  explicit ESMEventCB(nsIContent* aTarget) : mTarget(aTarget) {}
+
+  virtual void HandleEvent(EventChainPostVisitor& aVisitor)
+  {
+    if (aVisitor.mPresContext) {
+      nsIFrame* frame = aVisitor.mPresContext->GetPrimaryFrameFor(mTarget);
+      if (frame) {
+        frame->HandleEvent(aVisitor.mPresContext,
+                           aVisitor.mEvent->AsGUIEvent(),
+                           &aVisitor.mEventStatus);
+      }
+    }
+  }
+
+  nsCOMPtr<nsIContent> mTarget;
+};
+
+/*static*/ bool
+EventStateManager::IsHandlingUserInput()
+{
+  if (sUserInputEventDepth <= 0) {
+    return false;
+  }
+
+  TimeDuration timeout = nsContentUtils::HandlingUserInputTimeout();
+  return timeout <= TimeDuration(0) ||
+         (TimeStamp::Now() - sHandlingInputStart) <= timeout;
+}
+
+static void
+CreateMouseOrPointerWidgetEvent(WidgetMouseEvent* aMouseEvent,
+                                EventMessage aMessage,
+                                nsIContent* aRelatedContent,
+                                nsAutoPtr<WidgetMouseEvent>& aNewEvent)
+{
+  WidgetPointerEvent* sourcePointer = aMouseEvent->AsPointerEvent();
+  if (sourcePointer) {
+    PROFILER_LABEL("Input", "DispatchPointerEvent",
+      js::ProfileEntry::Category::EVENTS);
+
+    nsAutoPtr<WidgetPointerEvent> newPointerEvent;
+    newPointerEvent =
+      new WidgetPointerEvent(aMouseEvent->IsTrusted(), aMessage,
+                             aMouseEvent->mWidget);
+    newPointerEvent->mIsPrimary = sourcePointer->mIsPrimary;
+    newPointerEvent->mWidth = sourcePointer->mWidth;
+    newPointerEvent->mHeight = sourcePointer->mHeight;
+    newPointerEvent->inputSource = sourcePointer->inputSource;
+    newPointerEvent->relatedTarget =
+      nsIPresShell::GetPointerCapturingContent(sourcePointer->pointerId)
+        ? nullptr
+        : aRelatedContent;
+    aNewEvent = newPointerEvent.forget();
+  } else {
+    aNewEvent =
+      new WidgetMouseEvent(aMouseEvent->IsTrusted(), aMessage,
+                           aMouseEvent->mWidget, WidgetMouseEvent::eReal);
+    aNewEvent->relatedTarget = aRelatedContent;
+  }
+  aNewEvent->mRefPoint = aMouseEvent->mRefPoint;
+  aNewEvent->mModifiers = aMouseEvent->mModifiers;
+  aNewEvent->button = aMouseEvent->button;
+  aNewEvent->buttons = aMouseEvent->buttons;
+  aNewEvent->pressure = aMouseEvent->pressure;
+  aNewEvent->mPluginEvent = aMouseEvent->mPluginEvent;
+  aNewEvent->inputSource = aMouseEvent->inputSource;
+  aNewEvent->pointerId = aMouseEvent->pointerId;
+}
+
+nsIFrame*
+EventStateManager::DispatchMouseOrPointerEvent(WidgetMouseEvent* aMouseEvent,
+                                               EventMessage aMessage,
+                                               nsIContent* aTargetContent,
+                                               nsIContent* aRelatedContent)
+{
+  // http://dvcs.w3.org/hg/webevents/raw-file/default/mouse-lock.html#methods
+  // "[When the mouse is locked on an element...e]vents that require the concept
+  // of a mouse cursor must not be dispatched (for example: mouseover, mouseout).
+  if (sIsPointerLocked &&
+      (aMessage == eMouseLeave ||
+       aMessage == eMouseEnter ||
+       aMessage == eMouseOver ||
+       aMessage == eMouseOut)) {
+    mCurrentTargetContent = nullptr;
+    nsCOMPtr<Element> pointerLockedElement =
+      do_QueryReferent(EventStateManager::sPointerLockedElement);
+    if (!pointerLockedElement) {
+      NS_WARNING("Should have pointer locked element, but didn't.");
+      return nullptr;
+    }
+    nsCOMPtr<nsIContent> content = do_QueryInterface(pointerLockedElement);
+    return mPresContext->GetPrimaryFrameFor(content);
+  }
+
+  mCurrentTargetContent = nullptr;
+
+  if (!aTargetContent) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIContent> targetContent = aTargetContent;
+  nsCOMPtr<nsIContent> relatedContent = aRelatedContent;
+
+  nsAutoPtr<WidgetMouseEvent> dispatchEvent;
+  CreateMouseOrPointerWidgetEvent(aMouseEvent, aMessage,
+                                  relatedContent, dispatchEvent);
+
+  nsWeakFrame previousTarget = mCurrentTarget;
+  mCurrentTargetContent = targetContent;
+
+  nsIFrame* targetFrame = nullptr;
+
+  if (aMouseEvent->AsMouseEvent()) {
+    PROFILER_LABEL("Input", "DispatchMouseEvent",
+      js::ProfileEntry::Category::EVENTS);
+  }
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+  ESMEventCB callback(targetContent);
+  EventDispatcher::Dispatch(targetContent, mPresContext, dispatchEvent, nullptr,
+                            &status, &callback);
+
+  if (mPresContext) {
+    // Although the primary frame was checked in event callback, it may not be
+    // the same object after event dispatch and handling, so refetch it.
+    targetFrame = mPresContext->GetPrimaryFrameFor(targetContent);
+
+    // If we are entering/leaving remote content, dispatch a mouse enter/exit
+    // event to the remote frame.
+    if (IsRemoteTarget(targetContent)) {
+      if (aMessage == eMouseOut) {
+        // For remote content, send a "top-level" widget mouse exit event.
+        nsAutoPtr<WidgetMouseEvent> remoteEvent;
+        CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseExitFromWidget,
+                                        relatedContent, remoteEvent);
+        remoteEvent->mExitFrom = WidgetMouseEvent::eTopLevel;
+
+        // mCurrentTarget is set to the new target, so we must reset it to the
+        // old target and then dispatch a cross-process event. (mCurrentTarget
+        // will be set back below.) HandleCrossProcessEvent will query for the
+        // proper target via GetEventTarget which will return mCurrentTarget.
+        mCurrentTarget = targetFrame;
+        HandleCrossProcessEvent(remoteEvent, &status);
+      } else if (aMessage == eMouseOver) {
+        nsAutoPtr<WidgetMouseEvent> remoteEvent;
+        CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseEnterIntoWidget,
+                                        relatedContent, remoteEvent);
+        HandleCrossProcessEvent(remoteEvent, &status);
+      }
+    }
+  }
+
+  mCurrentTargetContent = nullptr;
+  mCurrentTarget = previousTarget;
+
+  return targetFrame;
+}
+
+class EnterLeaveDispatcher
+{
+public:
+  EnterLeaveDispatcher(EventStateManager* aESM,
+                       nsIContent* aTarget, nsIContent* aRelatedTarget,
+                       WidgetMouseEvent* aMouseEvent,
+                       EventMessage aEventMessage)
+    : mESM(aESM)
+    , mMouseEvent(aMouseEvent)
+    , mEventMessage(aEventMessage)
+  {
+    nsPIDOMWindowInner* win =
+      aTarget ? aTarget->OwnerDoc()->GetInnerWindow() : nullptr;
+    if (aMouseEvent->AsPointerEvent() ? win && win->HasPointerEnterLeaveEventListeners() :
+                                        win && win->HasMouseEnterLeaveEventListeners()) {
+      mRelatedTarget = aRelatedTarget ?
+        aRelatedTarget->FindFirstNonChromeOnlyAccessContent() : nullptr;
+      nsINode* commonParent = nullptr;
+      if (aTarget && aRelatedTarget) {
+        commonParent =
+          nsContentUtils::GetCommonAncestor(aTarget, aRelatedTarget);
+      }
+      nsIContent* current = aTarget;
+      // Note, it is ok if commonParent is null!
+      while (current && current != commonParent) {
+        if (!current->ChromeOnlyAccess()) {
+          mTargets.AppendObject(current);
+        }
+        // mouseenter/leave is fired only on elements.
+        current = current->GetParent();
+      }
+    }
+  }
+
+  ~EnterLeaveDispatcher()
+  {
+    if (mEventMessage == eMouseEnter || mEventMessage == ePointerEnter) {
+      for (int32_t i = mTargets.Count() - 1; i >= 0; --i) {
+        mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage,
+                                          mTargets[i], mRelatedTarget);
+      }
+    } else {
+      for (int32_t i = 0; i < mTargets.Count(); ++i) {
+        mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage,
+                                          mTargets[i], mRelatedTarget);
+      }
+    }
+  }
+
+  EventStateManager* mESM;
+  nsCOMArray<nsIContent> mTargets;
+  nsCOMPtr<nsIContent> mRelatedTarget;
+  WidgetMouseEvent* mMouseEvent;
+  EventMessage mEventMessage;
+};
+
+void
+EventStateManager::NotifyMouseOut(WidgetMouseEvent* aMouseEvent,
+                                  nsIContent* aMovingInto)
+{
+  OverOutElementsWrapper* wrapper = GetWrapperByEventID(aMouseEvent);
+
+  if (!wrapper->mLastOverElement)
+    return;
+  // Before firing mouseout, check for recursion
+  if (wrapper->mLastOverElement == wrapper->mFirstOutEventElement)
+    return;
+
+  if (wrapper->mLastOverFrame) {
+    // if the frame is associated with a subdocument,
+    // tell the subdocument that we're moving out of it
+    nsSubDocumentFrame* subdocFrame = do_QueryFrame(wrapper->mLastOverFrame.GetFrame());
+    if (subdocFrame) {
+      nsCOMPtr<nsIDocShell> docshell;
+      subdocFrame->GetDocShell(getter_AddRefs(docshell));
+      if (docshell) {
+        RefPtr<nsPresContext> presContext;
+        docshell->GetPresContext(getter_AddRefs(presContext));
+
+        if (presContext) {
+          EventStateManager* kidESM = presContext->EventStateManager();
+          // Not moving into any element in this subdocument
+          kidESM->NotifyMouseOut(aMouseEvent, nullptr);
+        }
+      }
+    }
+  }
+  // That could have caused DOM events which could wreak havoc. Reverify
+  // things and be careful.
+  if (!wrapper->mLastOverElement)
+    return;
+
+  // Store the first mouseOut event we fire and don't refire mouseOut
+  // to that element while the first mouseOut is still ongoing.
+  wrapper->mFirstOutEventElement = wrapper->mLastOverElement;
+
+  // Don't touch hover state if aMovingInto is non-null.  Caller will update
+  // hover state itself, and we have optimizations for hover switching between
+  // two nearby elements both deep in the DOM tree that would be defeated by
+  // switching the hover state to null here.
+  bool isPointer = aMouseEvent->mClass == ePointerEventClass;
+  if (!aMovingInto && !isPointer) {
+    // Unset :hover
+    SetContentState(nullptr, NS_EVENT_STATE_HOVER);
+  }
+
+  // In case we go out from capturing element (retargetedByPointerCapture is true)
+  // we should dispatch ePointerLeave event and only for capturing element.
+  RefPtr<nsIContent> movingInto = aMouseEvent->retargetedByPointerCapture
+                                    ? wrapper->mLastOverElement->GetParent()
+                                    : aMovingInto;
+
+  EnterLeaveDispatcher leaveDispatcher(this, wrapper->mLastOverElement,
+                                       movingInto, aMouseEvent,
+                                       isPointer ? ePointerLeave : eMouseLeave);
+
+  // Fire mouseout
+  DispatchMouseOrPointerEvent(aMouseEvent, isPointer ? ePointerOut : eMouseOut,
+                              wrapper->mLastOverElement, aMovingInto);
+
+  wrapper->mLastOverFrame = nullptr;
+  wrapper->mLastOverElement = nullptr;
+
+  // Turn recursion protection back off
+  wrapper->mFirstOutEventElement = nullptr;
+}
+
+void
+EventStateManager::NotifyMouseOver(WidgetMouseEvent* aMouseEvent,
+                                   nsIContent* aContent)
+{
+  NS_ASSERTION(aContent, "Mouse must be over something");
+
+  // If pointer capture is set, we should suppress pointerover/pointerenter events
+  // for all elements except element which have pointer capture.
+  bool dispatch = !aMouseEvent->retargetedByPointerCapture;
+
+  OverOutElementsWrapper* wrapper = GetWrapperByEventID(aMouseEvent);
+
+  if (wrapper->mLastOverElement == aContent && dispatch)
+    return;
+
+  // Before firing mouseover, check for recursion
+  if (aContent == wrapper->mFirstOverEventElement)
+    return;
+
+  // Check to see if we're a subdocument and if so update the parent
+  // document's ESM state to indicate that the mouse is over the
+  // content associated with our subdocument.
+  EnsureDocument(mPresContext);
+  if (nsIDocument *parentDoc = mDocument->GetParentDocument()) {
+    if (nsIContent *docContent = parentDoc->FindContentForSubDocument(mDocument)) {
+      if (nsIPresShell *parentShell = parentDoc->GetShell()) {
+        EventStateManager* parentESM =
+          parentShell->GetPresContext()->EventStateManager();
+        parentESM->NotifyMouseOver(aMouseEvent, docContent);
+      }
+    }
+  }
+  // Firing the DOM event in the parent document could cause all kinds
+  // of havoc.  Reverify and take care.
+  if (wrapper->mLastOverElement == aContent && dispatch)
+    return;
+
+  // Remember mLastOverElement as the related content for the
+  // DispatchMouseOrPointerEvent() call below, since NotifyMouseOut() resets it, bug 298477.
+  nsCOMPtr<nsIContent> lastOverElement = wrapper->mLastOverElement;
+
+  bool isPointer = aMouseEvent->mClass == ePointerEventClass;
+  
+  Maybe<EnterLeaveDispatcher> enterDispatcher;
+  if (dispatch) {
+    enterDispatcher.emplace(this, aContent, lastOverElement, aMouseEvent,
+                            isPointer ? ePointerEnter : eMouseEnter);
+  }
+
+  NotifyMouseOut(aMouseEvent, aContent);
+
+  // Store the first mouseOver event we fire and don't refire mouseOver
+  // to that element while the first mouseOver is still ongoing.
+  wrapper->mFirstOverEventElement = aContent;
+
+  if (!isPointer) {
+    SetContentState(aContent, NS_EVENT_STATE_HOVER);
+  }
+
+  if (dispatch) {
+    // Fire mouseover
+    wrapper->mLastOverFrame = 
+      DispatchMouseOrPointerEvent(aMouseEvent,
+                                  isPointer ? ePointerOver : eMouseOver,
+                                  aContent, lastOverElement);
+    wrapper->mLastOverElement = aContent;
+  } else {
+    wrapper->mLastOverFrame = nullptr;
+    wrapper->mLastOverElement = nullptr;
+  }
+
+  // Turn recursion protection back off
+  wrapper->mFirstOverEventElement = nullptr;
+}
+
+// Returns the center point of the window's client area. This is
+// in widget coordinates, i.e. relative to the widget's top-left
+// corner, not in screen coordinates, the same units that UIEvent::
+// refpoint is in. It may not be the exact center of the window if
+// the platform requires rounding the coordinate.
+static LayoutDeviceIntPoint
+GetWindowClientRectCenter(nsIWidget* aWidget)
+{
+  NS_ENSURE_TRUE(aWidget, LayoutDeviceIntPoint(0, 0));
+
+  LayoutDeviceIntRect rect = aWidget->GetClientBounds();
+  LayoutDeviceIntPoint point(rect.x + rect.width / 2,
+                             rect.y + rect.height / 2);
+  int32_t round = aWidget->RoundsWidgetCoordinatesTo();
+  point.x = point.x / round * round;
+  point.y = point.y / round * round;
+  return point - aWidget->WidgetToScreenOffset();
+}
+
+void
+EventStateManager::GeneratePointerEnterExit(EventMessage aMessage,
+                                            WidgetMouseEvent* aEvent)
+{
+  WidgetPointerEvent pointerEvent(*aEvent);
+  pointerEvent.mMessage = aMessage;
+  GenerateMouseEnterExit(&pointerEvent);
+}
+
+void
+EventStateManager::GenerateMouseEnterExit(WidgetMouseEvent* aMouseEvent)
+{
+  EnsureDocument(mPresContext);
+  if (!mDocument)
+    return;
+
+  // Hold onto old target content through the event and reset after.
+  nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;
+
+  switch(aMouseEvent->mMessage) {
+  case eMouseMove:
+    {
+      // Mouse movement is reported on the MouseEvent.movement{X,Y} fields.
+      // Movement is calculated in UIEvent::GetMovementPoint() as:
+      //   previous_mousemove_mRefPoint - current_mousemove_mRefPoint.
+      if (sIsPointerLocked && aMouseEvent->mWidget) {
+        // The pointer is locked. If the pointer is not located at the center of
+        // the window, dispatch a synthetic mousemove to return the pointer there.
+        // Doing this between "real" pointer moves gives the impression that the
+        // (locked) pointer can continue moving and won't stop at the screen
+        // boundary. We cancel the synthetic event so that we don't end up
+        // dispatching the centering move event to content.
+        LayoutDeviceIntPoint center =
+          GetWindowClientRectCenter(aMouseEvent->mWidget);
+        aMouseEvent->mLastRefPoint = center;
+        if (aMouseEvent->mRefPoint != center) {
+          // Mouse move doesn't finish at the center of the window. Dispatch a
+          // synthetic native mouse event to move the pointer back to the center
+          // of the window, to faciliate more movement. But first, record that
+          // we've dispatched a synthetic mouse movement, so we can cancel it
+          // in the other branch here.
+          sSynthCenteringPoint = center;
+          aMouseEvent->mWidget->SynthesizeNativeMouseMove(
+            center + aMouseEvent->mWidget->WidgetToScreenOffset(), nullptr);
+        } else if (aMouseEvent->mRefPoint == sSynthCenteringPoint) {
+          // This is the "synthetic native" event we dispatched to re-center the
+          // pointer. Cancel it so we don't expose the centering move to content.
+          aMouseEvent->StopPropagation();
+          // Clear sSynthCenteringPoint so we don't cancel other events
+          // targeted at the center.
+          sSynthCenteringPoint = kInvalidRefPoint;
+        }
+      } else if (sLastRefPoint == kInvalidRefPoint) {
+        // We don't have a valid previous mousemove mRefPoint. This is either
+        // the first move we've encountered, or the mouse has just re-entered
+        // the application window. We should report (0,0) movement for this
+        // case, so make the current and previous mRefPoints the same.
+        aMouseEvent->mLastRefPoint = aMouseEvent->mRefPoint;
+      } else {
+        aMouseEvent->mLastRefPoint = sLastRefPoint;
+      }
+
+      // Update the last known mRefPoint with the current mRefPoint.
+      sLastRefPoint = aMouseEvent->mRefPoint;
+    }
+    MOZ_FALLTHROUGH;
+  case ePointerMove:
+  case ePointerDown:
+    {
+      // Get the target content target (mousemove target == mouseover target)
+      nsCOMPtr<nsIContent> targetElement = GetEventTargetContent(aMouseEvent);
+      if (!targetElement) {
+        // We're always over the document root, even if we're only
+        // over dead space in a page (whose frame is not associated with
+        // any content) or in print preview dead space
+        targetElement = mDocument->GetRootElement();
+      }
+      if (targetElement) {
+        NotifyMouseOver(aMouseEvent, targetElement);
+      }
+    }
+    break;
+  case ePointerUp:
+    {
+      // Get the target content target (mousemove target == mouseover target)
+      nsCOMPtr<nsIContent> targetElement = GetEventTargetContent(aMouseEvent);
+      if (!targetElement) {
+        // We're always over the document root, even if we're only
+        // over dead space in a page (whose frame is not associated with
+        // any content) or in print preview dead space
+        targetElement = mDocument->GetRootElement();
+      }
+      if (targetElement) {
+        OverOutElementsWrapper* helper = GetWrapperByEventID(aMouseEvent);
+        if (helper) {
+          helper->mLastOverElement = targetElement;
+        }
+        NotifyMouseOut(aMouseEvent, nullptr);
+      }
+    }
+    break;
+  case ePointerLeave:
+  case ePointerCancel:
+  case eMouseExitFromWidget:
+    {
+      // This is actually the window mouse exit or pointer leave event. We're not moving
+      // into any new element.
+
+      OverOutElementsWrapper* helper = GetWrapperByEventID(aMouseEvent);
+      if (helper->mLastOverFrame &&
+          nsContentUtils::GetTopLevelWidget(aMouseEvent->mWidget) !=
+          nsContentUtils::GetTopLevelWidget(helper->mLastOverFrame->GetNearestWidget())) {
+        // the Mouse/PointerOut event widget doesn't have same top widget with
+        // mLastOverFrame, it's a spurious event for mLastOverFrame
+        break;
+      }
+
+      // Reset sLastRefPoint, so that we'll know not to report any
+      // movement the next time we re-enter the window.
+      sLastRefPoint = kInvalidRefPoint;
+
+      NotifyMouseOut(aMouseEvent, nullptr);
+    }
+    break;
+  default:
+    break;
+  }
+
+  // reset mCurretTargetContent to what it was
+  mCurrentTargetContent = targetBeforeEvent;
+}
+
+OverOutElementsWrapper*
+EventStateManager::GetWrapperByEventID(WidgetMouseEvent* aEvent)
+{
+  WidgetPointerEvent* pointer = aEvent->AsPointerEvent();
+  if (!pointer) {
+    MOZ_ASSERT(aEvent->AsMouseEvent() != nullptr);
+    if (!mMouseEnterLeaveHelper) {
+      mMouseEnterLeaveHelper = new OverOutElementsWrapper();
+    }
+    return mMouseEnterLeaveHelper;
+  }
+  RefPtr<OverOutElementsWrapper> helper;
+  if (!mPointersEnterLeaveHelper.Get(pointer->pointerId, getter_AddRefs(helper))) {
+    helper = new OverOutElementsWrapper();
+    mPointersEnterLeaveHelper.Put(pointer->pointerId, helper);
+  }
+
+  return helper;
+}
+
+/* static */ void
+EventStateManager::SetPointerLock(nsIWidget* aWidget,
+                                  nsIContent* aElement)
+{
+  // NOTE: aElement will be nullptr when unlocking.
+  sIsPointerLocked = !!aElement;
+
+  // Reset mouse wheel transaction
+  WheelTransaction::EndTransaction();
+
+  // Deal with DnD events
+  nsCOMPtr<nsIDragService> dragService =
+    do_GetService("@mozilla.org/widget/dragservice;1");
+
+  if (sIsPointerLocked) {
+    MOZ_ASSERT(aWidget, "Locking pointer requires a widget");
+
+    // Store the last known ref point so we can reposition the pointer after unlock.
+    sPreLockPoint = sLastRefPoint;
+
+    // Fire a synthetic mouse move to ensure event state is updated. We first
+    // set the mouse to the center of the window, so that the mouse event
+    // doesn't report any movement.
+    sLastRefPoint = GetWindowClientRectCenter(aWidget);
+    aWidget->SynthesizeNativeMouseMove(
+      sLastRefPoint + aWidget->WidgetToScreenOffset(), nullptr);
+
+    // Suppress DnD
+    if (dragService) {
+      dragService->Suppress();
+    }
+  } else {
+    // Unlocking, so return pointer to the original position by firing a
+    // synthetic mouse event. We first reset sLastRefPoint to its
+    // pre-pointerlock position, so that the synthetic mouse event reports
+    // no movement.
+    sLastRefPoint = sPreLockPoint;
+    // Reset SynthCenteringPoint to invalid so that next time we start
+    // locking pointer, it has its initial value.
+    sSynthCenteringPoint = kInvalidRefPoint;
+    if (aWidget) {
+      aWidget->SynthesizeNativeMouseMove(
+        sPreLockPoint + aWidget->WidgetToScreenOffset(), nullptr);
+    }
+
+    // Unsuppress DnD
+    if (dragService) {
+      dragService->Unsuppress();
+    }
+  }
+}
+
+void
+EventStateManager::GenerateDragDropEnterExit(nsPresContext* aPresContext,
+                                             WidgetDragEvent* aDragEvent)
+{
+  //Hold onto old target content through the event and reset after.
+  nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;
+
+  switch(aDragEvent->mMessage) {
+  case eDragOver:
+    {
+      // when dragging from one frame to another, events are fired in the
+      // order: dragexit, dragenter, dragleave
+      if (sLastDragOverFrame != mCurrentTarget) {
+        //We'll need the content, too, to check if it changed separately from the frames.
+        nsCOMPtr<nsIContent> lastContent;
+        nsCOMPtr<nsIContent> targetContent;
+        mCurrentTarget->GetContentForEvent(aDragEvent,
+                                           getter_AddRefs(targetContent));
+
+        if (sLastDragOverFrame) {
+          //The frame has changed but the content may not have. Check before dispatching to content
+          sLastDragOverFrame->GetContentForEvent(aDragEvent,
+                                                 getter_AddRefs(lastContent));
+
+          FireDragEnterOrExit(sLastDragOverFrame->PresContext(),
+                              aDragEvent, eDragExit,
+                              targetContent, lastContent, sLastDragOverFrame);
+        }
+
+        FireDragEnterOrExit(aPresContext, aDragEvent, eDragEnter,
+                            lastContent, targetContent, mCurrentTarget);
+
+        if (sLastDragOverFrame) {
+          FireDragEnterOrExit(sLastDragOverFrame->PresContext(),
+                              aDragEvent, eDragLeave,
+                              targetContent, lastContent, sLastDragOverFrame);
+        }
+
+        sLastDragOverFrame = mCurrentTarget;
+      }
+    }
+    break;
+
+  case eDragExit:
+    {
+      //This is actually the window mouse exit event.
+      if (sLastDragOverFrame) {
+        nsCOMPtr<nsIContent> lastContent;
+        sLastDragOverFrame->GetContentForEvent(aDragEvent,
+                                               getter_AddRefs(lastContent));
+
+        RefPtr<nsPresContext> lastDragOverFramePresContext = sLastDragOverFrame->PresContext();
+        FireDragEnterOrExit(lastDragOverFramePresContext,
+                            aDragEvent, eDragExit,
+                            nullptr, lastContent, sLastDragOverFrame);
+        FireDragEnterOrExit(lastDragOverFramePresContext,
+                            aDragEvent, eDragLeave,
+                            nullptr, lastContent, sLastDragOverFrame);
+
+        sLastDragOverFrame = nullptr;
+      }
+    }
+    break;
+
+  default:
+    break;
+  }
+
+  //reset mCurretTargetContent to what it was
+  mCurrentTargetContent = targetBeforeEvent;
+
+  // Now flush all pending notifications, for better responsiveness.
+  FlushPendingEvents(aPresContext);
+}
+
+void
+EventStateManager::FireDragEnterOrExit(nsPresContext* aPresContext,
+                                       WidgetDragEvent* aDragEvent,
+                                       EventMessage aMessage,
+                                       nsIContent* aRelatedTarget,
+                                       nsIContent* aTargetContent,
+                                       nsWeakFrame& aTargetFrame)
+{
+  nsEventStatus status = nsEventStatus_eIgnore;
+  WidgetDragEvent event(aDragEvent->IsTrusted(), aMessage, aDragEvent->mWidget);
+  event.mRefPoint = aDragEvent->mRefPoint;
+  event.mModifiers = aDragEvent->mModifiers;
+  event.buttons = aDragEvent->buttons;
+  event.relatedTarget = aRelatedTarget;
+  event.inputSource = aDragEvent->inputSource;
+
+  mCurrentTargetContent = aTargetContent;
+
+  if (aTargetContent != aRelatedTarget) {
+    //XXX This event should still go somewhere!!
+    if (aTargetContent) {
+      EventDispatcher::Dispatch(aTargetContent, aPresContext, &event,
+                                nullptr, &status);
+    }
+
+    // adjust the drag hover if the dragenter event was cancelled or this is a drag exit
+    if (status == nsEventStatus_eConsumeNoDefault || aMessage == eDragExit) {
+      SetContentState((aMessage == eDragEnter) ? aTargetContent : nullptr,
+                      NS_EVENT_STATE_DRAGOVER);
+    }
+
+    // collect any changes to moz cursor settings stored in the event's
+    // data transfer.
+    if (aMessage == eDragLeave || aMessage == eDragExit ||
+        aMessage == eDragEnter) {
+      UpdateDragDataTransfer(&event);
+    }
+  }
+
+  // Finally dispatch the event to the frame
+  if (aTargetFrame)
+    aTargetFrame->HandleEvent(aPresContext, &event, &status);
+}
+
+void
+EventStateManager::UpdateDragDataTransfer(WidgetDragEvent* dragEvent)
+{
+  NS_ASSERTION(dragEvent, "drag event is null in UpdateDragDataTransfer!");
+  if (!dragEvent->mDataTransfer) {
+    return;
+  }
+
+  nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+
+  if (dragSession) {
+    // the initial dataTransfer is the one from the dragstart event that
+    // was set on the dragSession when the drag began.
+    nsCOMPtr<nsIDOMDataTransfer> initialDataTransfer;
+    dragSession->GetDataTransfer(getter_AddRefs(initialDataTransfer));
+    if (initialDataTransfer) {
+      // retrieve the current moz cursor setting and save it.
+      nsAutoString mozCursor;
+      dragEvent->mDataTransfer->GetMozCursor(mozCursor);
+      initialDataTransfer->SetMozCursor(mozCursor);
+    }
+  }
+}
+
+nsresult
+EventStateManager::SetClickCount(WidgetMouseEvent* aEvent,
+                                 nsEventStatus* aStatus)
+{
+  nsCOMPtr<nsIContent> mouseContent;
+  nsIContent* mouseContentParent = nullptr;
+  if (mCurrentTarget) {
+    mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(mouseContent));
+  }
+  if (mouseContent) {
+    if (mouseContent->IsNodeOfType(nsINode::eTEXT)) {
+      mouseContent = mouseContent->GetParent();
+    }
+    if (mouseContent && mouseContent->IsRootOfNativeAnonymousSubtree()) {
+      mouseContentParent = mouseContent->GetParent();
+    }
+  }
+
+  switch (aEvent->button) {
+  case WidgetMouseEvent::eLeftButton:
+    if (aEvent->mMessage == eMouseDown) {
+      mLastLeftMouseDownContent = mouseContent;
+      mLastLeftMouseDownContentParent = mouseContentParent;
+    } else if (aEvent->mMessage == eMouseUp) {
+      if (mLastLeftMouseDownContent == mouseContent ||
+          mLastLeftMouseDownContentParent == mouseContent ||
+          mLastLeftMouseDownContent == mouseContentParent) {
+        aEvent->mClickCount = mLClickCount;
+        mLClickCount = 0;
+      } else {
+        aEvent->mClickCount = 0;
+      }
+      mLastLeftMouseDownContent = nullptr;
+      mLastLeftMouseDownContentParent = nullptr;
+    }
+    break;
+
+  case WidgetMouseEvent::eMiddleButton:
+    if (aEvent->mMessage == eMouseDown) {
+      mLastMiddleMouseDownContent = mouseContent;
+      mLastMiddleMouseDownContentParent = mouseContentParent;
+    } else if (aEvent->mMessage == eMouseUp) {
+      if (mLastMiddleMouseDownContent == mouseContent ||
+          mLastMiddleMouseDownContentParent == mouseContent ||
+          mLastMiddleMouseDownContent == mouseContentParent) {
+        aEvent->mClickCount = mMClickCount;
+        mMClickCount = 0;
+      } else {
+        aEvent->mClickCount = 0;
+      }
+      mLastMiddleMouseDownContent = nullptr;
+      mLastMiddleMouseDownContentParent = nullptr;
+    }
+    break;
+
+  case WidgetMouseEvent::eRightButton:
+    if (aEvent->mMessage == eMouseDown) {
+      mLastRightMouseDownContent = mouseContent;
+      mLastRightMouseDownContentParent = mouseContentParent;
+    } else if (aEvent->mMessage == eMouseUp) {
+      if (mLastRightMouseDownContent == mouseContent ||
+          mLastRightMouseDownContentParent == mouseContent ||
+          mLastRightMouseDownContent == mouseContentParent) {
+        aEvent->mClickCount = mRClickCount;
+        mRClickCount = 0;
+      } else {
+        aEvent->mClickCount = 0;
+      }
+      mLastRightMouseDownContent = nullptr;
+      mLastRightMouseDownContentParent = nullptr;
+    }
+    break;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+EventStateManager::CheckForAndDispatchClick(WidgetMouseEvent* aEvent,
+                                            nsEventStatus* aStatus)
+{
+  nsresult ret = NS_OK;
+
+  //If mouse is still over same element, clickcount will be > 1.
+  //If it has moved it will be zero, so no click.
+  if (aEvent->mClickCount) {
+    //Check that the window isn't disabled before firing a click
+    //(see bug 366544).
+    if (aEvent->mWidget && !aEvent->mWidget->IsEnabled()) {
+      return ret;
+    }
+    //fire click
+    bool notDispatchToContents =
+     (aEvent->button == WidgetMouseEvent::eMiddleButton ||
+      aEvent->button == WidgetMouseEvent::eRightButton);
+
+    WidgetMouseEvent event(aEvent->IsTrusted(), eMouseClick,
+                           aEvent->mWidget, WidgetMouseEvent::eReal);
+    event.mRefPoint = aEvent->mRefPoint;
+    event.mClickCount = aEvent->mClickCount;
+    event.mModifiers = aEvent->mModifiers;
+    event.buttons = aEvent->buttons;
+    event.mTime = aEvent->mTime;
+    event.mTimeStamp = aEvent->mTimeStamp;
+    event.mFlags.mNoContentDispatch = notDispatchToContents;
+    event.button = aEvent->button;
+    event.inputSource = aEvent->inputSource;
+
+    nsCOMPtr<nsIPresShell> presShell = mPresContext->GetPresShell();
+    if (presShell) {
+      nsCOMPtr<nsIContent> mouseContent = GetEventTargetContent(aEvent);
+      // Click events apply to *elements* not nodes. At this point the target
+      // content may have been reset to some non-element content, and so we need
+      // to walk up the closest ancestor element, just like we do in
+      // nsPresShell::HandlePositionedEvent.
+      while (mouseContent && !mouseContent->IsElement()) {
+        mouseContent = mouseContent->GetParent();
+      }
+
+      if (!mouseContent && !mCurrentTarget) {
+        return NS_OK;
+      }
+
+      // HandleEvent clears out mCurrentTarget which we might need again
+      nsWeakFrame currentTarget = mCurrentTarget;
+      ret = presShell->HandleEventWithTarget(&event, currentTarget,
+                                             mouseContent, aStatus);
+      if (NS_SUCCEEDED(ret) && aEvent->mClickCount == 2 &&
+          mouseContent && mouseContent->IsInComposedDoc()) {
+        //fire double click
+        WidgetMouseEvent event2(aEvent->IsTrusted(), eMouseDoubleClick,
+                                aEvent->mWidget, WidgetMouseEvent::eReal);
+        event2.mRefPoint = aEvent->mRefPoint;
+        event2.mClickCount = aEvent->mClickCount;
+        event2.mModifiers = aEvent->mModifiers;
+        event2.buttons = aEvent->buttons;
+        event2.mFlags.mNoContentDispatch = notDispatchToContents;
+        event2.button = aEvent->button;
+        event2.inputSource = aEvent->inputSource;
+
+        ret = presShell->HandleEventWithTarget(&event2, currentTarget,
+                                               mouseContent, aStatus);
+      }
+    }
+  }
+  return ret;
+}
+
+nsIFrame*
+EventStateManager::GetEventTarget()
+{
+  nsIPresShell *shell;
+  if (mCurrentTarget ||
+      !mPresContext ||
+      !(shell = mPresContext->GetPresShell())) {
+    return mCurrentTarget;
+  }
+
+  if (mCurrentTargetContent) {
+    mCurrentTarget = mPresContext->GetPrimaryFrameFor(mCurrentTargetContent);
+    if (mCurrentTarget) {
+      return mCurrentTarget;
+    }
+  }
+
+  nsIFrame* frame = shell->GetEventTargetFrame();
+  return (mCurrentTarget = frame);
+}
+
+already_AddRefed<nsIContent>
+EventStateManager::GetEventTargetContent(WidgetEvent* aEvent)
+{
+  if (aEvent &&
+      (aEvent->mMessage == eFocus || aEvent->mMessage == eBlur)) {
+    nsCOMPtr<nsIContent> content = GetFocusedContent();
+    return content.forget();
+  }
+
+  if (mCurrentTargetContent) {
+    nsCOMPtr<nsIContent> content = mCurrentTargetContent;
+    return content.forget();
+  }
+
+  nsCOMPtr<nsIContent> content;
+
+  nsIPresShell *presShell = mPresContext->GetPresShell();
+  if (presShell) {
+    content = presShell->GetEventTargetContent(aEvent);
+  }
+
+  // Some events here may set mCurrentTarget but not set the corresponding
+  // event target in the PresShell.
+  if (!content && mCurrentTarget) {
+    mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(content));
+  }
+
+  return content.forget();
+}
+
+static Element*
+GetLabelTarget(nsIContent* aPossibleLabel)
+{
+  mozilla::dom::HTMLLabelElement* label =
+    mozilla::dom::HTMLLabelElement::FromContent(aPossibleLabel);
+  if (!label)
+    return nullptr;
+
+  return label->GetLabeledElement();
+}
+
+static nsIContent* FindCommonAncestor(nsIContent *aNode1, nsIContent *aNode2)
+{
+  // Find closest common ancestor
+  if (aNode1 && aNode2) {
+    // Find the nearest common ancestor by counting the distance to the
+    // root and then walking up again, in pairs.
+    int32_t offset = 0;
+    nsIContent *anc1 = aNode1;
+    for (;;) {
+      ++offset;
+      nsIContent* parent = anc1->GetFlattenedTreeParent();
+      if (!parent)
+        break;
+      anc1 = parent;
+    }
+    nsIContent *anc2 = aNode2;
+    for (;;) {
+      --offset;
+      nsIContent* parent = anc2->GetFlattenedTreeParent();
+      if (!parent)
+        break;
+      anc2 = parent;
+    }
+    if (anc1 == anc2) {
+      anc1 = aNode1;
+      anc2 = aNode2;
+      while (offset > 0) {
+        anc1 = anc1->GetFlattenedTreeParent();
+        --offset;
+      }
+      while (offset < 0) {
+        anc2 = anc2->GetFlattenedTreeParent();
+        ++offset;
+      }
+      while (anc1 != anc2) {
+        anc1 = anc1->GetFlattenedTreeParent();
+        anc2 = anc2->GetFlattenedTreeParent();
+      }
+      return anc1;
+    }
+  }
+  return nullptr;
+}
+
+/* static */
+void
+EventStateManager::SetFullScreenState(Element* aElement, bool aIsFullScreen)
+{
+  DoStateChange(aElement, NS_EVENT_STATE_FULL_SCREEN, aIsFullScreen);
+}
+
+/* static */
+inline void
+EventStateManager::DoStateChange(Element* aElement, EventStates aState,
+                                 bool aAddState)
+{
+  if (aAddState) {
+    aElement->AddStates(aState);
+  } else {
+    aElement->RemoveStates(aState);
+  }
+}
+
+/* static */
+inline void
+EventStateManager::DoStateChange(nsIContent* aContent, EventStates aState,
+                                 bool aStateAdded)
+{
+  if (aContent->IsElement()) {
+    DoStateChange(aContent->AsElement(), aState, aStateAdded);
+  }
+}
+
+/* static */
+void
+EventStateManager::UpdateAncestorState(nsIContent* aStartNode,
+                                       nsIContent* aStopBefore,
+                                       EventStates aState,
+                                       bool aAddState)
+{
+  for (; aStartNode && aStartNode != aStopBefore;
+       aStartNode = aStartNode->GetFlattenedTreeParent()) {
+    // We might be starting with a non-element (e.g. a text node) and
+    // if someone is doing something weird might be ending with a
+    // non-element too (e.g. a document fragment)
+    if (!aStartNode->IsElement()) {
+      continue;
+    }
+    Element* element = aStartNode->AsElement();
+    DoStateChange(element, aState, aAddState);
+    Element* labelTarget = GetLabelTarget(element);
+    if (labelTarget) {
+      DoStateChange(labelTarget, aState, aAddState);
+    }
+  }
+
+  if (aAddState) {
+    // We might be in a situation where a node was in hover both
+    // because it was hovered and because the label for it was
+    // hovered, and while we stopped hovering the node the label is
+    // still hovered.  Or we might have had two nested labels for the
+    // same node, and while one is no longer hovered the other still
+    // is.  In that situation, the label that's still hovered will be
+    // aStopBefore or some ancestor of it, and the call we just made
+    // to UpdateAncestorState with aAddState = false would have
+    // removed the hover state from the node.  But the node should
+    // still be in hover state.  To handle this situation we need to
+    // keep walking up the tree and any time we find a label mark its
+    // corresponding node as still in our state.
+    for ( ; aStartNode; aStartNode = aStartNode->GetFlattenedTreeParent()) {
+      if (!aStartNode->IsElement()) {
+        continue;
+      }
+
+      Element* labelTarget = GetLabelTarget(aStartNode->AsElement());
+      if (labelTarget && !labelTarget->State().HasState(aState)) {
+        DoStateChange(labelTarget, aState, true);
+      }
+    }
+  }
+}
+
+bool
+EventStateManager::SetContentState(nsIContent* aContent, EventStates aState)
+{
+  // We manage 4 states here: ACTIVE, HOVER, DRAGOVER, URLTARGET
+  // The input must be exactly one of them.
+  NS_PRECONDITION(aState == NS_EVENT_STATE_ACTIVE ||
+                  aState == NS_EVENT_STATE_HOVER ||
+                  aState == NS_EVENT_STATE_DRAGOVER ||
+                  aState == NS_EVENT_STATE_URLTARGET,
+                  "Unexpected state");
+
+  nsCOMPtr<nsIContent> notifyContent1;
+  nsCOMPtr<nsIContent> notifyContent2;
+  bool updateAncestors;
+
+  if (aState == NS_EVENT_STATE_HOVER || aState == NS_EVENT_STATE_ACTIVE) {
+    // Hover and active are hierarchical
+    updateAncestors = true;
+
+    // check to see that this state is allowed by style. Check dragover too?
+    // XXX Is this even what we want?
+    if (mCurrentTarget)
+    {
+      const nsStyleUserInterface* ui = mCurrentTarget->StyleUserInterface();
+      if (ui->mUserInput == StyleUserInput::None) {
+        return false;
+      }
+    }
+
+    if (aState == NS_EVENT_STATE_ACTIVE) {
+      // Editable content can never become active since their default actions
+      // are disabled.  Watch out for editable content in native anonymous
+      // subtrees though, as they belong to text controls.
+      if (aContent && aContent->IsEditable() &&
+          !aContent->IsInNativeAnonymousSubtree()) {
+        aContent = nullptr;
+      }
+      if (aContent != mActiveContent) {
+        notifyContent1 = aContent;
+        notifyContent2 = mActiveContent;
+        mActiveContent = aContent;
+      }
+    } else {
+      NS_ASSERTION(aState == NS_EVENT_STATE_HOVER, "How did that happen?");
+      nsIContent* newHover;
+      
+      if (mPresContext->IsDynamic()) {
+        newHover = aContent;
+      } else {
+        NS_ASSERTION(!aContent ||
+                     aContent->GetComposedDoc() ==
+                       mPresContext->PresShell()->GetDocument(),
+                     "Unexpected document");
+        nsIFrame *frame = aContent ? aContent->GetPrimaryFrame() : nullptr;
+        if (frame && nsLayoutUtils::IsViewportScrollbarFrame(frame)) {
+          // The scrollbars of viewport should not ignore the hover state.
+          // Because they are *not* the content of the web page.
+          newHover = aContent;
+        } else {
+          // All contents of the web page should ignore the hover state.
+          newHover = nullptr;
+        }
+      }
+
+      if (newHover != mHoverContent) {
+        notifyContent1 = newHover;
+        notifyContent2 = mHoverContent;
+        mHoverContent = newHover;
+      }
+    }
+  } else {
+    updateAncestors = false;
+    if (aState == NS_EVENT_STATE_DRAGOVER) {
+      if (aContent != sDragOverContent) {
+        notifyContent1 = aContent;
+        notifyContent2 = sDragOverContent;
+        sDragOverContent = aContent;
+      }
+    } else if (aState == NS_EVENT_STATE_URLTARGET) {
+      if (aContent != mURLTargetContent) {
+        notifyContent1 = aContent;
+        notifyContent2 = mURLTargetContent;
+        mURLTargetContent = aContent;
+      }
+    }
+  }
+
+  // We need to keep track of which of notifyContent1 and notifyContent2 is
+  // getting the state set and which is getting it unset.  If both are
+  // non-null, then notifyContent1 is having the state set and notifyContent2
+  // is having it unset.  But if one of them is null, we need to keep track of
+  // the right thing for notifyContent1 explicitly.
+  bool content1StateSet = true;
+  if (!notifyContent1) {
+    // This is ok because FindCommonAncestor wouldn't find anything
+    // anyway if notifyContent1 is null.
+    notifyContent1 = notifyContent2;
+    notifyContent2 = nullptr;
+    content1StateSet = false;
+  }
+
+  if (notifyContent1 && mPresContext) {
+    EnsureDocument(mPresContext);
+    if (mDocument) {
+      nsAutoScriptBlocker scriptBlocker;
+
+      if (updateAncestors) {
+        nsCOMPtr<nsIContent> commonAncestor =
+          FindCommonAncestor(notifyContent1, notifyContent2);
+        if (notifyContent2) {
+          // It's very important to first notify the state removal and
+          // then the state addition, because due to labels it's
+          // possible that we're removing state from some element but
+          // then adding it again (say because mHoverContent changed
+          // from a control to its label).
+          UpdateAncestorState(notifyContent2, commonAncestor, aState, false);
+        }
+        UpdateAncestorState(notifyContent1, commonAncestor, aState,
+                            content1StateSet);
+      } else {
+        if (notifyContent2) {
+          DoStateChange(notifyContent2, aState, false);
+        }
+        DoStateChange(notifyContent1, aState, content1StateSet);
+      }
+    }
+  }
+
+  return true;
+}
+
+void
+EventStateManager::ResetLastOverForContent(
+                     const uint32_t& aIdx,
+                     RefPtr<OverOutElementsWrapper>& aElemWrapper,
+                     nsIContent* aContent)
+{
+  if (aElemWrapper && aElemWrapper->mLastOverElement &&
+      nsContentUtils::ContentIsDescendantOf(aElemWrapper->mLastOverElement,
+                                            aContent)) {
+    aElemWrapper->mLastOverElement = nullptr;
+  }
+}
+
+void
+EventStateManager::ContentRemoved(nsIDocument* aDocument, nsIContent* aContent)
+{
+  /*
+   * Anchor and area elements when focused or hovered might make the UI to show
+   * the current link. We want to make sure that the UI gets informed when they
+   * are actually removed from the DOM.
+   */
+  if (aContent->IsAnyOfHTMLElements(nsGkAtoms::a, nsGkAtoms::area) &&
+      (aContent->AsElement()->State().HasAtLeastOneOfStates(NS_EVENT_STATE_FOCUS |
+                                                            NS_EVENT_STATE_HOVER))) {
+    nsGenericHTMLElement* element = static_cast<nsGenericHTMLElement*>(aContent);
+    element->LeaveLink(
+      element->GetPresContext(nsGenericHTMLElement::eForComposedDoc));
+  }
+
+  IMEStateManager::OnRemoveContent(mPresContext, aContent);
+
+  // inform the focus manager that the content is being removed. If this
+  // content is focused, the focus will be removed without firing events.
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm)
+    fm->ContentRemoved(aDocument, aContent);
+
+  if (mHoverContent &&
+      nsContentUtils::ContentIsDescendantOf(mHoverContent, aContent)) {
+    // Since hover is hierarchical, set the current hover to the
+    // content's parent node.
+    SetContentState(aContent->GetParent(), NS_EVENT_STATE_HOVER);
+  }
+
+  if (mActiveContent &&
+      nsContentUtils::ContentIsDescendantOf(mActiveContent, aContent)) {
+    // Active is hierarchical, so set the current active to the
+    // content's parent node.
+    SetContentState(aContent->GetParent(), NS_EVENT_STATE_ACTIVE);
+  }
+
+  if (sDragOverContent &&
+      sDragOverContent->OwnerDoc() == aContent->OwnerDoc() &&
+      nsContentUtils::ContentIsDescendantOf(sDragOverContent, aContent)) {
+    sDragOverContent = nullptr;
+  }
+
+  // See bug 292146 for why we want to null this out
+  ResetLastOverForContent(0, mMouseEnterLeaveHelper, aContent);
+  for (auto iter = mPointersEnterLeaveHelper.Iter();
+       !iter.Done();
+       iter.Next()) {
+    ResetLastOverForContent(iter.Key(), iter.Data(), aContent);
+  }
+}
+
+bool
+EventStateManager::EventStatusOK(WidgetGUIEvent* aEvent)
+{
+  return !(aEvent->mMessage == eMouseDown &&
+           aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton &&
+           !sNormalLMouseEventInProcess);
+}
+
+//-------------------------------------------
+// Access Key Registration
+//-------------------------------------------
+void
+EventStateManager::RegisterAccessKey(nsIContent* aContent, uint32_t aKey)
+{
+  if (aContent && mAccessKeys.IndexOf(aContent) == -1)
+    mAccessKeys.AppendObject(aContent);
+}
+
+void
+EventStateManager::UnregisterAccessKey(nsIContent* aContent, uint32_t aKey)
+{
+  if (aContent)
+    mAccessKeys.RemoveObject(aContent);
+}
+
+uint32_t
+EventStateManager::GetRegisteredAccessKey(nsIContent* aContent)
+{
+  MOZ_ASSERT(aContent);
+
+  if (mAccessKeys.IndexOf(aContent) == -1)
+    return 0;
+
+  nsAutoString accessKey;
+  aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey);
+  return accessKey.First();
+}
+
+void
+EventStateManager::EnsureDocument(nsPresContext* aPresContext)
+{
+  if (!mDocument)
+    mDocument = aPresContext->Document();
+}
+
+void
+EventStateManager::FlushPendingEvents(nsPresContext* aPresContext)
+{
+  NS_PRECONDITION(nullptr != aPresContext, "nullptr ptr");
+  nsIPresShell *shell = aPresContext->GetPresShell();
+  if (shell) {
+    shell->FlushPendingNotifications(Flush_InterruptibleLayout);
+  }
+}
+
+nsIContent*
+EventStateManager::GetFocusedContent()
+{
+  nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+  EnsureDocument(mPresContext);
+  if (!fm || !mDocument)
+    return nullptr;
+
+  nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
+  return nsFocusManager::GetFocusedDescendant(mDocument->GetWindow(), false,
+                                              getter_AddRefs(focusedWindow));
+}
+
+//-------------------------------------------------------
+// Return true if the docshell is visible
+
+bool
+EventStateManager::IsShellVisible(nsIDocShell* aShell)
+{
+  NS_ASSERTION(aShell, "docshell is null");
+
+  nsCOMPtr<nsIBaseWindow> basewin = do_QueryInterface(aShell);
+  if (!basewin)
+    return true;
+
+  bool isVisible = true;
+  basewin->GetVisibility(&isVisible);
+
+  // We should be doing some additional checks here so that
+  // we don't tab into hidden tabs of tabbrowser.  -bryner
+
+  return isVisible;
+}
+
+nsresult
+EventStateManager::DoContentCommandEvent(WidgetContentCommandEvent* aEvent)
+{
+  EnsureDocument(mPresContext);
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE);
+  nsCOMPtr<nsPIDOMWindowOuter> window(mDocument->GetWindow());
+  NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsPIWindowRoot> root = window->GetTopWindowRoot();
+  NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
+  const char* cmd;
+  switch (aEvent->mMessage) {
+    case eContentCommandCut:
+      cmd = "cmd_cut";
+      break;
+    case eContentCommandCopy:
+      cmd = "cmd_copy";
+      break;
+    case eContentCommandPaste:
+      cmd = "cmd_paste";
+      break;
+    case eContentCommandDelete:
+      cmd = "cmd_delete";
+      break;
+    case eContentCommandUndo:
+      cmd = "cmd_undo";
+      break;
+    case eContentCommandRedo:
+      cmd = "cmd_redo";
+      break;
+    case eContentCommandPasteTransferable:
+      cmd = "cmd_pasteTransferable";
+      break;
+    case eContentCommandLookUpDictionary:
+      cmd = "cmd_lookUpDictionary";
+      break;
+    default:
+      return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  nsCOMPtr<nsIController> controller;
+  nsresult rv = root->GetControllerForCommand(cmd, getter_AddRefs(controller));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!controller) {
+    // When GetControllerForCommand succeeded but there is no controller, the
+    // command isn't supported.
+    aEvent->mIsEnabled = false;
+  } else {
+    bool canDoIt;
+    rv = controller->IsCommandEnabled(cmd, &canDoIt);
+    NS_ENSURE_SUCCESS(rv, rv);
+    aEvent->mIsEnabled = canDoIt;
+    if (canDoIt && !aEvent->mOnlyEnabledCheck) {
+      switch (aEvent->mMessage) {
+        case eContentCommandPasteTransferable: {
+          nsFocusManager* fm = nsFocusManager::GetFocusManager();
+          nsIContent* focusedContent = fm ? fm->GetFocusedContent() : nullptr;
+          RefPtr<TabParent> remote = TabParent::GetFrom(focusedContent);
+          if (remote) {
+            NS_ENSURE_TRUE(remote->Manager()->IsContentParent(), NS_ERROR_FAILURE);
+
+            nsCOMPtr<nsITransferable> transferable = aEvent->mTransferable;
+            IPCDataTransfer ipcDataTransfer;
+            ContentParent* cp = remote->Manager()->AsContentParent();
+            nsContentUtils::TransferableToIPCTransferable(transferable,
+                                                          &ipcDataTransfer,
+                                                          false, nullptr,
+                                                          cp);
+            bool isPrivateData = false;
+            transferable->GetIsPrivateData(&isPrivateData);
+            nsCOMPtr<nsIPrincipal> requestingPrincipal;
+            transferable->GetRequestingPrincipal(getter_AddRefs(requestingPrincipal));
+            remote->SendPasteTransferable(ipcDataTransfer, isPrivateData,
+                                          IPC::Principal(requestingPrincipal));
+            rv = NS_OK;
+          } else {
+            nsCOMPtr<nsICommandController> commandController = do_QueryInterface(controller);
+            NS_ENSURE_STATE(commandController);
+
+            nsCOMPtr<nsICommandParams> params = do_CreateInstance("@mozilla.org/embedcomp/command-params;1", &rv);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            rv = params->SetISupportsValue("transferable", aEvent->mTransferable);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            rv = commandController->DoCommandWithParams(cmd, params);
+          }
+          break;
+        }
+
+        case eContentCommandLookUpDictionary: {
+          nsCOMPtr<nsICommandController> commandController =
+            do_QueryInterface(controller);
+          if (NS_WARN_IF(!commandController)) {
+            return NS_ERROR_FAILURE;
+          }
+
+          nsCOMPtr<nsICommandParams> params =
+            do_CreateInstance("@mozilla.org/embedcomp/command-params;1", &rv);
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            return rv;
+          }
+
+          rv = params->SetLongValue("x", aEvent->mRefPoint.x);
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            return rv;
+          }
+
+          rv = params->SetLongValue("y", aEvent->mRefPoint.y);
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            return rv;
+          }
+
+          rv = commandController->DoCommandWithParams(cmd, params);
+          break;
+        }
+
+        default:
+          rv = controller->DoCommand(cmd);
+          break;
+      }
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  aEvent->mSucceeded = true;
+  return NS_OK;
+}
+
+nsresult
+EventStateManager::DoContentCommandScrollEvent(
+                     WidgetContentCommandEvent* aEvent)
+{
+  NS_ENSURE_TRUE(mPresContext, NS_ERROR_NOT_AVAILABLE);
+  nsIPresShell* ps = mPresContext->GetPresShell();
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_AVAILABLE);
+  NS_ENSURE_TRUE(aEvent->mScroll.mAmount != 0, NS_ERROR_INVALID_ARG);
+
+  nsIScrollableFrame::ScrollUnit scrollUnit;
+  switch (aEvent->mScroll.mUnit) {
+    case WidgetContentCommandEvent::eCmdScrollUnit_Line:
+      scrollUnit = nsIScrollableFrame::LINES;
+      break;
+    case WidgetContentCommandEvent::eCmdScrollUnit_Page:
+      scrollUnit = nsIScrollableFrame::PAGES;
+      break;
+    case WidgetContentCommandEvent::eCmdScrollUnit_Whole:
+      scrollUnit = nsIScrollableFrame::WHOLE;
+      break;
+    default:
+      return NS_ERROR_INVALID_ARG;
+  }
+
+  aEvent->mSucceeded = true;
+
+  nsIScrollableFrame* sf =
+    ps->GetFrameToScrollAsScrollable(nsIPresShell::eEither);
+  aEvent->mIsEnabled = sf ?
+    (aEvent->mScroll.mIsHorizontal ?
+      WheelHandlingUtils::CanScrollOn(sf, aEvent->mScroll.mAmount, 0) :
+      WheelHandlingUtils::CanScrollOn(sf, 0, aEvent->mScroll.mAmount)) : false;
+
+  if (!aEvent->mIsEnabled || aEvent->mOnlyEnabledCheck) {
+    return NS_OK;
+  }
+
+  nsIntPoint pt(0, 0);
+  if (aEvent->mScroll.mIsHorizontal) {
+    pt.x = aEvent->mScroll.mAmount;
+  } else {
+    pt.y = aEvent->mScroll.mAmount;
+  }
+
+  // The caller may want synchronous scrolling.
+  sf->ScrollBy(pt, scrollUnit, nsIScrollableFrame::INSTANT);
+  return NS_OK;
+}
+
+void
+EventStateManager::SetActiveManager(EventStateManager* aNewESM,
+                                    nsIContent* aContent)
+{
+  if (sActiveESM && aNewESM != sActiveESM) {
+    sActiveESM->SetContentState(nullptr, NS_EVENT_STATE_ACTIVE);
+  }
+  sActiveESM = aNewESM;
+  if (sActiveESM && aContent) {
+    sActiveESM->SetContentState(aContent, NS_EVENT_STATE_ACTIVE);
+  }
+}
+
+void
+EventStateManager::ClearGlobalActiveContent(EventStateManager* aClearer)
+{
+  if (aClearer) {
+    aClearer->SetContentState(nullptr, NS_EVENT_STATE_ACTIVE);
+    if (sDragOverContent) {
+      aClearer->SetContentState(nullptr, NS_EVENT_STATE_DRAGOVER);
+    }
+  }
+  if (sActiveESM && aClearer != sActiveESM) {
+    sActiveESM->SetContentState(nullptr, NS_EVENT_STATE_ACTIVE);
+  }
+  sActiveESM = nullptr;
+}
+
+/******************************************************************/
+/* mozilla::EventStateManager::DeltaAccumulator                   */
+/******************************************************************/
+
+void
+EventStateManager::DeltaAccumulator::InitLineOrPageDelta(
+                                       nsIFrame* aTargetFrame,
+                                       EventStateManager* aESM,
+                                       WidgetWheelEvent* aEvent)
+{
+  MOZ_ASSERT(aESM);
+  MOZ_ASSERT(aEvent);
+
+  // Reset if the previous wheel event is too old.
+  if (!mLastTime.IsNull()) {
+    TimeDuration duration = TimeStamp::Now() - mLastTime;
+    if (duration.ToMilliseconds() > WheelTransaction::GetTimeoutTime()) {
+      Reset();
+    }
+  }
+  // If we have accumulated delta,  we may need to reset it.
+  if (IsInTransaction()) {
+    // If wheel event type is changed, reset the values.
+    if (mHandlingDeltaMode != aEvent->mDeltaMode ||
+        mIsNoLineOrPageDeltaDevice != aEvent->mIsNoLineOrPageDelta) {
+      Reset();
+    } else {
+      // If the delta direction is changed, we should reset only the
+      // accumulated values.
+      if (mX && aEvent->mDeltaX && ((aEvent->mDeltaX > 0.0) != (mX > 0.0))) {
+        mX = mPendingScrollAmountX = 0.0;
+      }
+      if (mY && aEvent->mDeltaY && ((aEvent->mDeltaY > 0.0) != (mY > 0.0))) {
+        mY = mPendingScrollAmountY = 0.0;
+      }
+    }
+  }
+
+  mHandlingDeltaMode = aEvent->mDeltaMode;
+  mIsNoLineOrPageDeltaDevice = aEvent->mIsNoLineOrPageDelta;
+
+  // If it's handling neither a device that does not provide line or page deltas
+  // nor delta values multiplied by prefs, we must not modify lineOrPageDelta
+  // values.
+  if (!mIsNoLineOrPageDeltaDevice &&
+      !EventStateManager::WheelPrefs::GetInstance()->
+        NeedToComputeLineOrPageDelta(aEvent)) {
+    // Set the delta values to mX and mY.  They would be used when above block
+    // resets mX/mY/mPendingScrollAmountX/mPendingScrollAmountY if the direction
+    // is changed.
+    // NOTE: We shouldn't accumulate the delta values, it might could cause
+    //       overflow even though it's not a realistic situation.
+    if (aEvent->mDeltaX) {
+      mX = aEvent->mDeltaX;
+    }
+    if (aEvent->mDeltaY) {
+      mY = aEvent->mDeltaY;
+    }
+    mLastTime = TimeStamp::Now();
+    return;
+  }
+
+  mX += aEvent->mDeltaX;
+  mY += aEvent->mDeltaY;
+
+  if (mHandlingDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PIXEL) {
+    // Records pixel delta values and init mLineOrPageDeltaX and
+    // mLineOrPageDeltaY for wheel events which are caused by pixel only
+    // devices.  Ignore mouse wheel transaction for computing this.  The
+    // lineOrPageDelta values will be used by dispatching legacy
+    // eMouseScrollEventClass (DOMMouseScroll) but not be used for scrolling
+    // of default action.  The transaction should be used only for the default
+    // action.
+    nsIFrame* frame =
+      aESM->ComputeScrollTarget(aTargetFrame, aEvent,
+                                COMPUTE_LEGACY_MOUSE_SCROLL_EVENT_TARGET);
+    nsPresContext* pc =
+      frame ? frame->PresContext() : aTargetFrame->PresContext();
+    nsIScrollableFrame* scrollTarget = do_QueryFrame(frame);
+    nsSize scrollAmount = aESM->GetScrollAmount(pc, aEvent, scrollTarget);
+    nsIntSize scrollAmountInCSSPixels(
+      nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.width),
+      nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.height));
+
+    aEvent->mLineOrPageDeltaX = RoundDown(mX) / scrollAmountInCSSPixels.width;
+    aEvent->mLineOrPageDeltaY = RoundDown(mY) / scrollAmountInCSSPixels.height;
+
+    mX -= aEvent->mLineOrPageDeltaX * scrollAmountInCSSPixels.width;
+    mY -= aEvent->mLineOrPageDeltaY * scrollAmountInCSSPixels.height;
+  } else {
+    aEvent->mLineOrPageDeltaX = RoundDown(mX);
+    aEvent->mLineOrPageDeltaY = RoundDown(mY);
+    mX -= aEvent->mLineOrPageDeltaX;
+    mY -= aEvent->mLineOrPageDeltaY;
+  }
+
+  mLastTime = TimeStamp::Now();
+}
+
+void
+EventStateManager::DeltaAccumulator::Reset()
+{
+  mX = mY = 0.0;
+  mPendingScrollAmountX = mPendingScrollAmountY = 0.0;
+  mHandlingDeltaMode = UINT32_MAX;
+  mIsNoLineOrPageDeltaDevice = false;
+}
+
+nsIntPoint
+EventStateManager::DeltaAccumulator::ComputeScrollAmountForDefaultAction(
+                     WidgetWheelEvent* aEvent,
+                     const nsIntSize& aScrollAmountInDevPixels)
+{
+  MOZ_ASSERT(aEvent);
+
+  // If the wheel event is line scroll and the delta value is computed from
+  // system settings, allow to override the system speed.
+  bool allowScrollSpeedOverride =
+    (!aEvent->mCustomizedByUserPrefs &&
+     aEvent->mDeltaMode == nsIDOMWheelEvent::DOM_DELTA_LINE);
+  DeltaValues acceleratedDelta =
+    WheelTransaction::AccelerateWheelDelta(aEvent, allowScrollSpeedOverride);
+
+  nsIntPoint result(0, 0);
+  if (aEvent->mDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PIXEL) {
+    mPendingScrollAmountX += acceleratedDelta.deltaX;
+    mPendingScrollAmountY += acceleratedDelta.deltaY;
+  } else {
+    mPendingScrollAmountX +=
+      aScrollAmountInDevPixels.width * acceleratedDelta.deltaX;
+    mPendingScrollAmountY +=
+      aScrollAmountInDevPixels.height * acceleratedDelta.deltaY;
+  }
+  result.x = RoundDown(mPendingScrollAmountX);
+  result.y = RoundDown(mPendingScrollAmountY);
+  mPendingScrollAmountX -= result.x;
+  mPendingScrollAmountY -= result.y;
+
+  return result;
+}
+
+/******************************************************************/
+/* mozilla::EventStateManager::WheelPrefs                         */
+/******************************************************************/
+
+// static
+EventStateManager::WheelPrefs*
+EventStateManager::WheelPrefs::GetInstance()
+{
+  if (!sInstance) {
+    sInstance = new WheelPrefs();
+  }
+  return sInstance;
+}
+
+// static
+void
+EventStateManager::WheelPrefs::Shutdown()
+{
+  delete sInstance;
+  sInstance = nullptr;
+}
+
+// static
+void
+EventStateManager::WheelPrefs::OnPrefChanged(const char* aPrefName,
+                                             void* aClosure)
+{
+  // forget all prefs, it's not problem for performance.
+  sInstance->Reset();
+  DeltaAccumulator::GetInstance()->Reset();
+}
+
+EventStateManager::WheelPrefs::WheelPrefs()
+{
+  Reset();
+  Preferences::RegisterCallback(OnPrefChanged, "mousewheel.", nullptr);
+  Preferences::AddBoolVarCache(&sWheelEventsEnabledOnPlugins,
+                               "plugin.mousewheel.enabled",
+                               true);
+}
+
+EventStateManager::WheelPrefs::~WheelPrefs()
+{
+  Preferences::UnregisterCallback(OnPrefChanged, "mousewheel.", nullptr);
+}
+
+void
+EventStateManager::WheelPrefs::Reset()
+{
+  memset(mInit, 0, sizeof(mInit));
+
+}
+
+EventStateManager::WheelPrefs::Index
+EventStateManager::WheelPrefs::GetIndexFor(WidgetWheelEvent* aEvent)
+{
+  if (!aEvent) {
+    return INDEX_DEFAULT;
+  }
+
+  Modifiers modifiers =
+    (aEvent->mModifiers & (MODIFIER_ALT |
+                           MODIFIER_CONTROL |
+                           MODIFIER_META |
+                           MODIFIER_SHIFT |
+                           MODIFIER_OS));
+
+  switch (modifiers) {
+    case MODIFIER_ALT:
+      return INDEX_ALT;
+    case MODIFIER_CONTROL:
+      return INDEX_CONTROL;
+    case MODIFIER_META:
+      return INDEX_META;
+    case MODIFIER_SHIFT:
+      return INDEX_SHIFT;
+    case MODIFIER_OS:
+      return INDEX_OS;
+    default:
+      // If two or more modifier keys are pressed, we should use default
+      // settings.
+      return INDEX_DEFAULT;
+  }
+}
+
+void
+EventStateManager::WheelPrefs::GetBasePrefName(
+                     EventStateManager::WheelPrefs::Index aIndex,
+                     nsACString& aBasePrefName)
+{
+  aBasePrefName.AssignLiteral("mousewheel.");
+  switch (aIndex) {
+    case INDEX_ALT:
+      aBasePrefName.AppendLiteral("with_alt.");
+      break;
+    case INDEX_CONTROL:
+      aBasePrefName.AppendLiteral("with_control.");
+      break;
+    case INDEX_META:
+      aBasePrefName.AppendLiteral("with_meta.");
+      break;
+    case INDEX_SHIFT:
+      aBasePrefName.AppendLiteral("with_shift.");
+      break;
+    case INDEX_OS:
+      aBasePrefName.AppendLiteral("with_win.");
+      break;
+    case INDEX_DEFAULT:
+    default:
+      aBasePrefName.AppendLiteral("default.");
+      break;
+  }
+}
+
+void
+EventStateManager::WheelPrefs::Init(EventStateManager::WheelPrefs::Index aIndex)
+{
+  if (mInit[aIndex]) {
+    return;
+  }
+  mInit[aIndex] = true;
+
+  nsAutoCString basePrefName;
+  GetBasePrefName(aIndex, basePrefName);
+
+  nsAutoCString prefNameX(basePrefName);
+  prefNameX.AppendLiteral("delta_multiplier_x");
+  mMultiplierX[aIndex] =
+    static_cast<double>(Preferences::GetInt(prefNameX.get(), 100)) / 100;
+
+  nsAutoCString prefNameY(basePrefName);
+  prefNameY.AppendLiteral("delta_multiplier_y");
+  mMultiplierY[aIndex] =
+    static_cast<double>(Preferences::GetInt(prefNameY.get(), 100)) / 100;
+
+  nsAutoCString prefNameZ(basePrefName);
+  prefNameZ.AppendLiteral("delta_multiplier_z");
+  mMultiplierZ[aIndex] =
+    static_cast<double>(Preferences::GetInt(prefNameZ.get(), 100)) / 100;
+
+  nsAutoCString prefNameAction(basePrefName);
+  prefNameAction.AppendLiteral("action");
+  int32_t action = Preferences::GetInt(prefNameAction.get(), ACTION_SCROLL);
+  if (action < int32_t(ACTION_NONE) || action > int32_t(ACTION_LAST)) {
+    NS_WARNING("Unsupported action pref value, replaced with 'Scroll'.");
+    action = ACTION_SCROLL;
+  }
+  mActions[aIndex] = static_cast<Action>(action);
+
+  // Compute action values overridden by .override_x pref.
+  // At present, override is possible only for the x-direction
+  // because this pref is introduced mainly for tilt wheels.
+  prefNameAction.AppendLiteral(".override_x");
+  int32_t actionOverrideX = Preferences::GetInt(prefNameAction.get(), -1);
+  if (actionOverrideX < -1 || actionOverrideX > int32_t(ACTION_LAST)) {
+    NS_WARNING("Unsupported action override pref value, didn't override.");
+    actionOverrideX = -1;
+  }
+  mOverriddenActionsX[aIndex] = (actionOverrideX == -1)
+                              ? static_cast<Action>(action)
+                              : static_cast<Action>(actionOverrideX);
+}
+
+void
+EventStateManager::WheelPrefs::ApplyUserPrefsToDelta(WidgetWheelEvent* aEvent)
+{
+  if (aEvent->mCustomizedByUserPrefs) {
+    return;
+  }
+
+  Index index = GetIndexFor(aEvent);
+  Init(index);
+
+  aEvent->mDeltaX *= mMultiplierX[index];
+  aEvent->mDeltaY *= mMultiplierY[index];
+  aEvent->mDeltaZ *= mMultiplierZ[index];
+
+  // If the multiplier is 1.0 or -1.0, i.e., it doesn't change the absolute
+  // value, we should use lineOrPageDelta values which were set by widget.
+  // Otherwise, we need to compute them from accumulated delta values.
+  if (!NeedToComputeLineOrPageDelta(aEvent)) {
+    aEvent->mLineOrPageDeltaX *= static_cast<int32_t>(mMultiplierX[index]);
+    aEvent->mLineOrPageDeltaY *= static_cast<int32_t>(mMultiplierY[index]);
+  } else {
+    aEvent->mLineOrPageDeltaX = 0;
+    aEvent->mLineOrPageDeltaY = 0;
+  }
+
+  aEvent->mCustomizedByUserPrefs =
+    ((mMultiplierX[index] != 1.0) || (mMultiplierY[index] != 1.0) ||
+     (mMultiplierZ[index] != 1.0));
+}
+
+void
+EventStateManager::WheelPrefs::CancelApplyingUserPrefsFromOverflowDelta(
+                                 WidgetWheelEvent* aEvent)
+{
+  Index index = GetIndexFor(aEvent);
+  Init(index);
+
+  // XXX If the multiplier pref value is negative, the scroll direction was
+  //     changed and caused to scroll different direction.  In such case,
+  //     this method reverts the sign of overflowDelta.  Does it make widget
+  //     happy?  Although, widget can know the pref applied delta values by
+  //     referrencing the deltaX and deltaY of the event.
+
+  if (mMultiplierX[index]) {
+    aEvent->mOverflowDeltaX /= mMultiplierX[index];
+  }
+  if (mMultiplierY[index]) {
+    aEvent->mOverflowDeltaY /= mMultiplierY[index];
+  }
+}
+
+EventStateManager::WheelPrefs::Action
+EventStateManager::WheelPrefs::ComputeActionFor(WidgetWheelEvent* aEvent)
+{
+  Index index = GetIndexFor(aEvent);
+  Init(index);
+
+  bool deltaXPreferred =
+    (Abs(aEvent->mDeltaX) > Abs(aEvent->mDeltaY) &&
+     Abs(aEvent->mDeltaX) > Abs(aEvent->mDeltaZ));
+  Action* actions = deltaXPreferred ? mOverriddenActionsX : mActions;
+  if (actions[index] == ACTION_NONE || actions[index] == ACTION_SCROLL) {
+    return actions[index];
+  }
+
+  // Momentum events shouldn't run special actions.
+  if (aEvent->mIsMomentum) {
+    // Use the default action.  Note that user might kill the wheel scrolling.
+    Init(INDEX_DEFAULT);
+    return (actions[INDEX_DEFAULT] == ACTION_SCROLL) ? ACTION_SCROLL :
+                                                       ACTION_NONE;
+  }
+
+  return actions[index];
+}
+
+bool
+EventStateManager::WheelPrefs::NeedToComputeLineOrPageDelta(
+                                 WidgetWheelEvent* aEvent)
+{
+  Index index = GetIndexFor(aEvent);
+  Init(index);
+
+  return (mMultiplierX[index] != 1.0 && mMultiplierX[index] != -1.0) ||
+         (mMultiplierY[index] != 1.0 && mMultiplierY[index] != -1.0);
+}
+
+void
+EventStateManager::WheelPrefs::GetUserPrefsForEvent(WidgetWheelEvent* aEvent,
+                                                    double* aOutMultiplierX,
+                                                    double* aOutMultiplierY)
+{
+  Index index = GetIndexFor(aEvent);
+  Init(index);
+
+  *aOutMultiplierX = mMultiplierX[index];
+  *aOutMultiplierY = mMultiplierY[index];
+}
+
+// static
+bool
+EventStateManager::WheelPrefs::WheelEventsEnabledOnPlugins()
+{
+  if (!sInstance) {
+    GetInstance(); // initializing sWheelEventsEnabledOnPlugins
+  }
+  return sWheelEventsEnabledOnPlugins;
+}
+
+bool
+EventStateManager::WheelEventIsScrollAction(WidgetWheelEvent* aEvent)
+{
+  return aEvent->mMessage == eWheel &&
+         WheelPrefs::GetInstance()->ComputeActionFor(aEvent) == WheelPrefs::ACTION_SCROLL;
+}
+
+void
+EventStateManager::GetUserPrefsForWheelEvent(WidgetWheelEvent* aEvent,
+                                             double* aOutMultiplierX,
+                                             double* aOutMultiplierY)
+{
+  WheelPrefs::GetInstance()->GetUserPrefsForEvent(
+    aEvent, aOutMultiplierX, aOutMultiplierY);
+}
+
+bool
+EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedX(
+                                 WidgetWheelEvent* aEvent)
+{
+  Index index = GetIndexFor(aEvent);
+  Init(index);
+  return Abs(mMultiplierX[index]) >=
+           MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL;
+}
+
+bool
+EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedY(
+                                 WidgetWheelEvent* aEvent)
+{
+  Index index = GetIndexFor(aEvent);
+  Init(index);
+  return Abs(mMultiplierY[index]) >=
+           MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL;
+}
+
+/******************************************************************/
+/* mozilla::EventStateManager::Prefs                              */
+/******************************************************************/
+
+bool EventStateManager::Prefs::sKeyCausesActivation = true;
+bool EventStateManager::Prefs::sClickHoldContextMenu = false;
+int32_t EventStateManager::Prefs::sGenericAccessModifierKey = -1;
+int32_t EventStateManager::Prefs::sChromeAccessModifierMask = 0;
+int32_t EventStateManager::Prefs::sContentAccessModifierMask = 0;
+
+// static
+void
+EventStateManager::Prefs::Init()
+{
+  DebugOnly<nsresult> rv = Preferences::RegisterCallback(OnChange, "dom.popup_allowed_events");
+  MOZ_ASSERT(NS_SUCCEEDED(rv),
+             "Failed to observe \"dom.popup_allowed_events\"");
+
+  static bool sPrefsAlreadyCached = false;
+  if (sPrefsAlreadyCached) {
+    return;
+  }
+
+  rv = Preferences::AddBoolVarCache(&sKeyCausesActivation,
+                                    "accessibility.accesskeycausesactivation",
+                                    sKeyCausesActivation);
+  MOZ_ASSERT(NS_SUCCEEDED(rv),
+             "Failed to observe \"accessibility.accesskeycausesactivation\"");
+  rv = Preferences::AddBoolVarCache(&sClickHoldContextMenu,
+                                    "ui.click_hold_context_menus",
+                                    sClickHoldContextMenu);
+  MOZ_ASSERT(NS_SUCCEEDED(rv),
+             "Failed to observe \"ui.click_hold_context_menus\"");
+  rv = Preferences::AddIntVarCache(&sGenericAccessModifierKey,
+                                   "ui.key.generalAccessKey",
+                                   sGenericAccessModifierKey);
+  MOZ_ASSERT(NS_SUCCEEDED(rv),
+             "Failed to observe \"ui.key.generalAccessKey\"");
+  rv = Preferences::AddIntVarCache(&sChromeAccessModifierMask,
+                                   "ui.key.chromeAccess",
+                                   sChromeAccessModifierMask);
+  MOZ_ASSERT(NS_SUCCEEDED(rv),
+             "Failed to observe \"ui.key.chromeAccess\"");
+  rv = Preferences::AddIntVarCache(&sContentAccessModifierMask,
+                                   "ui.key.contentAccess",
+                                   sContentAccessModifierMask);
+  MOZ_ASSERT(NS_SUCCEEDED(rv),
+             "Failed to observe \"ui.key.contentAccess\"");
+  sPrefsAlreadyCached = true;
+}
+
+// static
+void
+EventStateManager::Prefs::OnChange(const char* aPrefName, void*)
+{
+  nsDependentCString prefName(aPrefName);
+  if (prefName.EqualsLiteral("dom.popup_allowed_events")) {
+    Event::PopupAllowedEventsChanged();
+  }
+}
+
+// static
+void
+EventStateManager::Prefs::Shutdown()
+{
+  Preferences::UnregisterCallback(OnChange, "dom.popup_allowed_events");
+}
+
+// static
+int32_t
+EventStateManager::Prefs::ChromeAccessModifierMask()
+{
+  return GetAccessModifierMask(nsIDocShellTreeItem::typeChrome);
+}
+
+// static
+int32_t
+EventStateManager::Prefs::ContentAccessModifierMask()
+{
+  return GetAccessModifierMask(nsIDocShellTreeItem::typeContent);
+}
+
+// static
+int32_t
+EventStateManager::Prefs::GetAccessModifierMask(int32_t aItemType)
+{
+  switch (sGenericAccessModifierKey) {
+    case -1:                             break; // use the individual prefs
+    case nsIDOMKeyEvent::DOM_VK_SHIFT:   return NS_MODIFIER_SHIFT;
+    case nsIDOMKeyEvent::DOM_VK_CONTROL: return NS_MODIFIER_CONTROL;
+    case nsIDOMKeyEvent::DOM_VK_ALT:     return NS_MODIFIER_ALT;
+    case nsIDOMKeyEvent::DOM_VK_META:    return NS_MODIFIER_META;
+    case nsIDOMKeyEvent::DOM_VK_WIN:     return NS_MODIFIER_OS;
+    default:                             return 0;
+  }
+
+  switch (aItemType) {
+    case nsIDocShellTreeItem::typeChrome:
+      return sChromeAccessModifierMask;
+    case nsIDocShellTreeItem::typeContent:
+      return sContentAccessModifierMask;
+    default:
+      return 0;
+  }
+}
+
+/******************************************************************/
+/* mozilla::AutoHandlingUserInputStatePusher                      */
+/******************************************************************/
+
+AutoHandlingUserInputStatePusher::AutoHandlingUserInputStatePusher(
+                                    bool aIsHandlingUserInput,
+                                    WidgetEvent* aEvent,
+                                    nsIDocument* aDocument) :
+  mIsHandlingUserInput(aIsHandlingUserInput),
+  mIsMouseDown(aEvent && aEvent->mMessage == eMouseDown),
+  mResetFMMouseButtonHandlingState(false)
+{
+  if (!aIsHandlingUserInput) {
+    return;
+  }
+  EventStateManager::StartHandlingUserInput();
+  if (mIsMouseDown) {
+    nsIPresShell::SetCapturingContent(nullptr, 0);
+    nsIPresShell::AllowMouseCapture(true);
+  }
+  if (!aDocument || !aEvent || !aEvent->IsTrusted()) {
+    return;
+  }
+  mResetFMMouseButtonHandlingState =
+    (aEvent->mMessage == eMouseDown || aEvent->mMessage == eMouseUp);
+  if (mResetFMMouseButtonHandlingState) {
+    nsFocusManager* fm = nsFocusManager::GetFocusManager();
+    NS_ENSURE_TRUE_VOID(fm);
+    // If it's in modal state, mouse button event handling may be nested.
+    // E.g., a modal dialog is opened at mousedown or mouseup event handler
+    // and the dialog is clicked.  Therefore, we should store current
+    // mouse button event handling document if nsFocusManager already has it.
+    mMouseButtonEventHandlingDocument =
+      fm->SetMouseButtonHandlingDocument(aDocument);
+  }
+}
+
+AutoHandlingUserInputStatePusher::~AutoHandlingUserInputStatePusher()
+{
+  if (!mIsHandlingUserInput) {
+    return;
+  }
+  EventStateManager::StopHandlingUserInput();
+  if (mIsMouseDown) {
+    nsIPresShell::AllowMouseCapture(false);
+  }
+  if (mResetFMMouseButtonHandlingState) {
+    nsFocusManager* fm = nsFocusManager::GetFocusManager();
+    NS_ENSURE_TRUE_VOID(fm);
+    nsCOMPtr<nsIDocument> handlingDocument =
+      fm->SetMouseButtonHandlingDocument(mMouseButtonEventHandlingDocument);
+  }
+}
+
+} // namespace mozilla