The Tor Browser: comparison layout/base/PositionedEventTargeting.cpp

--1:000000000000
+:73c819307dfc
+/* 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 / file comparison

comparison: layout/base/PositionedEventTargeting.cpp

layout/base/PositionedEventTargeting.cpp