The Tor Browser: layout/base/PositionedEventTargeting.cpp@b8a032363ba2 (annotated)

layout/base/PositionedEventTargeting.cpp@b8a032363ba2 (annotated)

layout/base/PositionedEventTargeting.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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 "PositionedEventTargeting.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/MouseEvents.h"
 #include "mozilla/Preferences.h"
 #include "nsLayoutUtils.h"
 #include "nsGkAtoms.h"
 #include "nsPrintfCString.h"
 #include "mozilla/dom/Element.h"
 #include "nsRegion.h"
 #include "nsDeviceContext.h"
 #include "nsIFrame.h"
 #include <algorithm>
 namespace mozilla {
 /*
  * The basic goal of FindFrameTargetedByInputEvent() is to find a good
  * target element that can respond to mouse events. Both mouse events and touch
  * events are targeted at this element. Note that even for touch events, we
  * check responsiveness to mouse events. We assume Web authors
  * designing for touch events will take their own steps to account for
  * inaccurate touch events.
  *
  * IsElementClickable() encapsulates the heuristic that determines whether an
  * element is expected to respond to mouse events. An element is deemed
  * "clickable" if it has registered listeners for "click", "mousedown" or
  * "mouseup", or is on a whitelist of element tags (<a>, <button>, <input>,
  * <select>, <textarea>, <label>), or has role="button", or is a link, or
  * is a suitable XUL element.
  * Any descendant (in the same document) of a clickable element is also
  * deemed clickable since events will propagate to the clickable element from its
  * descendant.
  *
  * If the element directly under the event position is clickable (or
  * event radii are disabled), we always use that element. Otherwise we collect
  * all frames intersecting a rectangle around the event position (taking CSS
  * transforms into account) and choose the best candidate in GetClosest().
  * Only IsElementClickable() candidates are considered; if none are found,
  * then we revert to targeting the element under the event position.
  * We ignore candidates outside the document subtree rooted by the
  * document of the element directly under the event position. This ensures that
  * event listeners in ancestor documents don't make it completely impossible
  * to target a non-clickable element in a child document.
  *
  * When both a frame and its ancestor are in the candidate list, we ignore
  * the ancestor. Otherwise a large ancestor element with a mouse event listener
  * and some descendant elements that need to be individually targetable would
  * disable intelligent targeting of those descendants within its bounds.
  *
  * GetClosest() computes the transformed axis-aligned bounds of each
  * candidate frame, then computes the Manhattan distance from the event point
  * to the bounds rect (which can be zero). The frame with the
  * shortest distance is chosen. For visited links we multiply the distance
  * by a specified constant weight; this can be used to make visited links
  * more or less likely to be targeted than non-visited links.
  */
 struct EventRadiusPrefs
 {
   uint32_t mVisitedWeight; // in percent, i.e. default is 100
   uint32_t mSideRadii[4]; // TRBL order, in millimetres
   bool mEnabled;
   bool mRegistered;
   bool mTouchOnly;
 };
 static EventRadiusPrefs sMouseEventRadiusPrefs;
 static EventRadiusPrefs sTouchEventRadiusPrefs;
 static const EventRadiusPrefs*
 GetPrefsFor(nsEventStructType aEventStructType)
 {
   EventRadiusPrefs* prefs = nullptr;
   const char* prefBranch = nullptr;
   if (aEventStructType == NS_TOUCH_EVENT) {
     prefBranch = "touch";
     prefs = &sTouchEventRadiusPrefs;
   } else if (aEventStructType == NS_MOUSE_EVENT) {
     // Mostly for testing purposes
     prefBranch = "mouse";
     prefs = &sMouseEventRadiusPrefs;
   } else {
     return nullptr;
   }
   if (!prefs->mRegistered) {
     prefs->mRegistered = true;
     nsPrintfCString enabledPref("ui.%s.radius.enabled", prefBranch);
     Preferences::AddBoolVarCache(&prefs->mEnabled, enabledPref.get(), false);
     nsPrintfCString visitedWeightPref("ui.%s.radius.visitedWeight", prefBranch);
     Preferences::AddUintVarCache(&prefs->mVisitedWeight, visitedWeightPref.get(), 100);
     static const char prefNames[4][9] =
       { "topmm", "rightmm", "bottommm", "leftmm" };
     for (int32_t i = 0; i < 4; ++i) {
       nsPrintfCString radiusPref("ui.%s.radius.%s", prefBranch, prefNames[i]);
       Preferences::AddUintVarCache(&prefs->mSideRadii[i], radiusPref.get(), 0);
     }
     if (aEventStructType == NS_MOUSE_EVENT) {
       Preferences::AddBoolVarCache(&prefs->mTouchOnly,
           "ui.mouse.radius.inputSource.touchOnly", true);
     } else {
       prefs->mTouchOnly = false;
     }
   }
   return prefs;
 }
 static bool
 HasMouseListener(nsIContent* aContent)
 {
   if (EventListenerManager* elm = aContent->GetExistingListenerManager()) {
     return elm->HasListenersFor(nsGkAtoms::onclick) ||
            elm->HasListenersFor(nsGkAtoms::onmousedown) ||
            elm->HasListenersFor(nsGkAtoms::onmouseup);
   }
   return false;
 }
 static bool gTouchEventsRegistered = false;
 static int32_t gTouchEventsEnabled = 0;
 static bool
 HasTouchListener(nsIContent* aContent)
 {
   EventListenerManager* elm = aContent->GetExistingListenerManager();
   if (!elm) {
     return false;
   }
   if (!gTouchEventsRegistered) {
     Preferences::AddIntVarCache(&gTouchEventsEnabled,
       "dom.w3c_touch_events.enabled", gTouchEventsEnabled);
     gTouchEventsRegistered = true;
   }
   if (!gTouchEventsEnabled) {
     return false;
   }
   return elm->HasListenersFor(nsGkAtoms::ontouchstart) ||
          elm->HasListenersFor(nsGkAtoms::ontouchend);
 }
 static bool
 IsElementClickable(nsIFrame* aFrame, nsIAtom* stopAt = nullptr)
 {
   // Input events propagate up the content tree so we'll follow the content
   // ancestors to look for elements accepting the click.
   for (nsIContent* content = aFrame->GetContent(); content;
        content = content->GetFlattenedTreeParent()) {
     nsIAtom* tag = content->Tag();
     if (content->IsHTML() && stopAt && tag == stopAt) {
       break;
     }
     if (HasTouchListener(content) || HasMouseListener(content)) {
       return true;
     }
     if (content->IsHTML()) {
       if (tag == nsGkAtoms::button ||
           tag == nsGkAtoms::input ||
           tag == nsGkAtoms::select ||
           tag == nsGkAtoms::textarea ||
           tag == nsGkAtoms::label) {
         return true;
       }
       // Bug 921928: we don't have access to the content of remote iframe.
       // So fluffing won't go there. We do an optimistic assumption here:
       // that the content of the remote iframe needs to be a target.
       if (tag == nsGkAtoms::iframe &&
           content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::mozbrowser,
                                nsGkAtoms::_true, eIgnoreCase) &&
           content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::Remote,
                                nsGkAtoms::_true, eIgnoreCase)) {
         return true;
       }
     } else if (content->IsXUL()) {
       nsIAtom* tag = content->Tag();
       // See nsCSSFrameConstructor::FindXULTagData. This code is not
       // really intended to be used with XUL, though.
       if (tag == nsGkAtoms::button ||
           tag == nsGkAtoms::checkbox ||
           tag == nsGkAtoms::radio ||
           tag == nsGkAtoms::autorepeatbutton ||
           tag == nsGkAtoms::menu ||
           tag == nsGkAtoms::menubutton ||
           tag == nsGkAtoms::menuitem ||
           tag == nsGkAtoms::menulist ||
           tag == nsGkAtoms::scrollbarbutton ||
           tag == nsGkAtoms::resizer) {
         return true;
       }
     }
     static nsIContent::AttrValuesArray clickableRoles[] =
       { &nsGkAtoms::button, &nsGkAtoms::key, nullptr };
     if (content->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::role,
                                  clickableRoles, eIgnoreCase) >= 0) {
       return true;
     }
     if (content->IsEditable()) {
       return true;
     }
     nsCOMPtr<nsIURI> linkURI;
     if (content->IsLink(getter_AddRefs(linkURI))) {
       return true;
     }
   }
   return false;
 }
 static nscoord
 AppUnitsFromMM(nsIFrame* aFrame, uint32_t aMM, bool aVertical)
 {
   nsPresContext* pc = aFrame->PresContext();
   float result = float(aMM) *
     (pc->DeviceContext()->AppUnitsPerPhysicalInch() / MM_PER_INCH_FLOAT);
   return NSToCoordRound(result);
 }
 /**
  * Clip aRect with the bounds of aFrame in the coordinate system of
  * aRootFrame. aRootFrame is an ancestor of aFrame.
  */
 static nsRect
 ClipToFrame(nsIFrame* aRootFrame, nsIFrame* aFrame, nsRect& aRect)
 {
   nsRect bound = nsLayoutUtils::TransformFrameRectToAncestor(
     aFrame, nsRect(nsPoint(0, 0), aFrame->GetSize()), aRootFrame);
   nsRect result = bound.Intersect(aRect);
   return result;
 }
 static nsRect
 GetTargetRect(nsIFrame* aRootFrame, const nsPoint& aPointRelativeToRootFrame,
               nsIFrame* aRestrictToDescendants, const EventRadiusPrefs* aPrefs)
 {
   nsMargin m(AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[0], true),
              AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[1], false),
              AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[2], true),
              AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[3], false));
   nsRect r(aPointRelativeToRootFrame, nsSize(0,0));
   r.Inflate(m);
   return ClipToFrame(aRootFrame, aRestrictToDescendants, r);
 }
 static float
 ComputeDistanceFromRect(const nsPoint& aPoint, const nsRect& aRect)
 {
   nscoord dx = std::max(0, std::max(aRect.x - aPoint.x, aPoint.x - aRect.XMost()));
   nscoord dy = std::max(0, std::max(aRect.y - aPoint.y, aPoint.y - aRect.YMost()));
   return float(NS_hypot(dx, dy));
 }
 static float
 ComputeDistanceFromRegion(const nsPoint& aPoint, const nsRegion& aRegion)
 {
   MOZ_ASSERT(!aRegion.IsEmpty(), "can't compute distance between point and empty region");
   nsRegionRectIterator iter(aRegion);
   const nsRect* r;
   float minDist = -1;
   while ((r = iter.Next()) != nullptr) {
     float dist = ComputeDistanceFromRect(aPoint, *r);
     if (dist < minDist || minDist < 0) {
       minDist = dist;
     }
   }
   return minDist;
 }
 // Subtract aRegion from aExposedRegion as long as that doesn't make the
 // exposed region get too complex or removes a big chunk of the exposed region.
 static void
 SubtractFromExposedRegion(nsRegion* aExposedRegion, const nsRegion& aRegion)
 {
   if (aRegion.IsEmpty())
     return;
   nsRegion tmp;
   tmp.Sub(*aExposedRegion, aRegion);
   // Don't let *aExposedRegion get too complex, but don't let it fluff out to
   // its bounds either. Do let aExposedRegion get more complex if by doing so
   // we reduce its area by at least half.
   if (tmp.GetNumRects() <= 15 || tmp.Area() <= aExposedRegion->Area()/2) {
     *aExposedRegion = tmp;
   }
 }
 static nsIFrame*
 GetClosest(nsIFrame* aRoot, const nsPoint& aPointRelativeToRootFrame,
            const nsRect& aTargetRect, const EventRadiusPrefs* aPrefs,
            nsIFrame* aRestrictToDescendants, nsTArray<nsIFrame*>& aCandidates)
 {
   nsIFrame* bestTarget = nullptr;
   // Lower is better; distance is in appunits
   float bestDistance = 1e6f;
   nsRegion exposedRegion(aTargetRect);
   for (uint32_t i = 0; i < aCandidates.Length(); ++i) {
     nsIFrame* f = aCandidates[i];
     bool preservesAxisAlignedRectangles = false;
     nsRect borderBox = nsLayoutUtils::TransformFrameRectToAncestor(f,
         nsRect(nsPoint(0, 0), f->GetSize()), aRoot, &preservesAxisAlignedRectangles);
     nsRegion region;
     region.And(exposedRegion, borderBox);
     if (region.IsEmpty()) {
       continue;
     }
     if (preservesAxisAlignedRectangles) {
       // Subtract from the exposed region if we have a transform that won't make
       // the bounds include a bunch of area that we don't actually cover.
       SubtractFromExposedRegion(&exposedRegion, region);
     }
     if (!IsElementClickable(f)) {
       continue;
     }
     // If our current closest frame is a descendant of 'f', skip 'f' (prefer
     // the nested frame).
     if (bestTarget && nsLayoutUtils::IsProperAncestorFrameCrossDoc(f, bestTarget, aRoot)) {
       continue;
     }
     if (!nsLayoutUtils::IsAncestorFrameCrossDoc(aRestrictToDescendants, f, aRoot)) {
       continue;
     }
     // distance is in appunits
     float distance = ComputeDistanceFromRegion(aPointRelativeToRootFrame, region);
     nsIContent* content = f->GetContent();
     if (content && content->IsElement() &&
         content->AsElement()->State().HasState(
                                         EventStates(NS_EVENT_STATE_VISITED))) {
       distance *= aPrefs->mVisitedWeight / 100.0f;
     }
     if (distance < bestDistance) {
       bestDistance = distance;
       bestTarget = f;
     }
   }
   return bestTarget;
 }
 nsIFrame*
 FindFrameTargetedByInputEvent(const WidgetGUIEvent* aEvent,
                               nsIFrame* aRootFrame,
                               const nsPoint& aPointRelativeToRootFrame,
                               uint32_t aFlags)
 {
   uint32_t flags = (aFlags & INPUT_IGNORE_ROOT_SCROLL_FRAME) ?
      nsLayoutUtils::IGNORE_ROOT_SCROLL_FRAME : 0;
   nsIFrame* target =
     nsLayoutUtils::GetFrameForPoint(aRootFrame, aPointRelativeToRootFrame, flags);
   const EventRadiusPrefs* prefs = GetPrefsFor(aEvent->eventStructType);
   if (!prefs || !prefs->mEnabled || (target && IsElementClickable(target, nsGkAtoms::body))) {
     return target;
   }
   // Do not modify targeting for actual mouse hardware; only for mouse
   // events generated by touch-screen hardware.
   if (aEvent->eventStructType == NS_MOUSE_EVENT &&
       prefs->mTouchOnly &&
       aEvent->AsMouseEvent()->inputSource !=
         nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) {
     return target;
   }
   // If the exact target is non-null, only consider candidate targets in the same
   // document as the exact target. Otherwise, if an ancestor document has
   // a mouse event handler for example, targets that are !IsElementClickable can
   // never be targeted --- something nsSubDocumentFrame in an ancestor document
   // would be targeted instead.
   nsIFrame* restrictToDescendants = target ?
     target->PresContext()->PresShell()->GetRootFrame() : aRootFrame;
   nsRect targetRect = GetTargetRect(aRootFrame, aPointRelativeToRootFrame,
                                     restrictToDescendants, prefs);
   nsAutoTArray<nsIFrame*,8> candidates;
   nsresult rv = nsLayoutUtils::GetFramesForArea(aRootFrame, targetRect, candidates, flags);
   if (NS_FAILED(rv)) {
     return target;
   }
   nsIFrame* closestClickable =
     GetClosest(aRootFrame, aPointRelativeToRootFrame, targetRect, prefs,
                restrictToDescendants, candidates);
   return closestClickable ? closestClickable : target;
 }
 }

The Tor Browser / annotate

layout/base/PositionedEventTargeting.cpp@b8a032363ba2 (annotated)

layout/base/PositionedEventTargeting.cpp