Compute effective touch action in StyleAdjuster.

third_party/WebKit/Source/core/css/resolver/StyleAdjuster.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
@@ skipping 17 matching lines @@
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/css/resolver/StyleAdjuster.h"
 
 #include "core/HTMLNames.h"
 #include "core/SVGNames.h"
 #include "core/dom/ContainerNode.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
+#include "core/dom/NodeComputedStyle.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLTableCellElement.h"
 #include "core/html/HTMLTextAreaElement.h"
+#include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/style/ComputedStyle.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "core/svg/SVGSVGElement.h"
 #include "platform/Length.h"
 #include "platform/transforms/TransformOperations.h"
 #include "platform/wtf/Assertions.h"
 
 namespace blink {
 
@@ skipping 302 matching lines @@
     if (style.PaddingBefore().IsPercentOrCalc() ||
         style.PaddingAfter().IsPercentOrCalc())
       UseCounter::Count(document,
                         UseCounter::kFlexboxPercentagePaddingVertical);
     if (style.MarginBefore().IsPercentOrCalc() ||
         style.MarginAfter().IsPercentOrCalc())
       UseCounter::Count(document, UseCounter::kFlexboxPercentageMarginVertical);
   }
 }
 
+static void AdjustEffectiveTouchAction(ComputedStyle& style,
+                                       const ComputedStyle& parent_style,
+                                       Element* element) {
+  TouchAction action = parent_style.GetEffectiveTouchAction();
+
+  bool is_svg_root = element && element->IsSVGElement() &&
+                     isSVGSVGElement(*element) && element->parentNode() &&
+                     !element->parentNode()->IsSVGElement();
+  bool is_non_replaced_inline_elements =
+      style.IsDisplayInlineType() &&
+      !(style.IsDisplayReplacedType() || is_svg_root ||
+        isHTMLImageElement(element));
+  bool is_table_row_or_column = style.IsDisplayTableRowOrColumnType();
+
+  // According to W3C specs, touch actions are only supported by elements that
+  // support both the CSS width and height properties.

[flackr, 2017/06/07 18:21:47]

Should we remove the computed touch action then? i.e.
style.SetTouchAction(kTouchActionAuto);

[sunxd, 2017/06/08 19:08:11]

I think in the original code, we continue with tree walking even if the current
layout object doesn't support touch action. This means an element without height
or width can have an effective touch action inherited from its ancestor. I think
we should maintain the same behavior here?

In the pointer events specs, it is said:
A touch behavior is supported if it conforms to the touch-action property of
each element between the hit tested element and its nearest ancestor with the
default touch behavior (including both the hit tested element and the element
with the default touch behavior).

I think we do not allow CSS touch-action property on those elements (their
touch-action is equal to auto?), but it can still have a touch behavior?

[flackr, 2017/06/08 19:35:21]

Sorry, I think there may be a misunderstanding, Still set the *effective* touch
action to be |action| so that it is properly inherited, but you should also set
the touch action to be auto since it's not allowed on that element. This will
mean that getComputedStyle(elem).touchAction == 'auto' but the effective touch
action will still inherit.

[sunxd, 2017/06/09 21:00:35]

OK, that sounds reasonable to me, done!

+  // See https://www.w3.org/TR/pointerevents/#the-touch-action-css-property.
+  if (is_non_replaced_inline_elements || is_table_row_or_column) {
+    style.SetEffectiveTouchAction(action);
+    return;
+  }
+
+  // When a gesture is started, the browser intersects the touch-action values
+  // of the touched element and all its ancestors up to the one that implements

[flackr, 2017/06/07 18:21:47]

Since we won't actually do a walk intersecting the touch-action when this
effective touch action computation lands we should phrase this differently,
perhaps:
The effective touch action is the intersection of the touch-action values of the
current element and all of its ancestors up to the one that implements the
gesture. Since panning is implemented by the scroller it is re-enabled for
scrolling elements.

[sunxd, 2017/06/08 19:08:12]

Done.

+  // the gesture. So a scrolling element should cancel all panning-restricted
+  // touch actions applied by ancestors of the scrolling element.
+  if (style.ScrollsOverflow())
+    action |= TouchAction::kTouchActionPan;
+
+  // The panning-restricted cancellation should also apply to iframes, so we
+  // allow (panning & local touch action) on the first descendant element of a
+  // iframe element.
+  if (element && element == element->GetDocument().documentElement() &&
+      element->GetDocument().LocalOwner()) {
+    const ComputedStyle* frame_style =
+        element->GetDocument().LocalOwner()->GetComputedStyle();

[flackr, 2017/06/07 18:21:47]

This confuses me, why do we need to mask with the iframe's document's touch
action as well as the local touch action style?

[sunxd, 2017/06/08 19:08:11]

I think we are masking with iframe's touch action style.

In this situation (from touch-action-iframe.html):

<iframe style='touch-action: none;' srcdoc="
  <div expected-action='pan-x-y'>
    Zoom (but not scroll) related touch-action bits propagate into iframes
  </div>
"></iframe>

The internal div should get a panning touch action. If we do not mask with the
iframe's effective touch action, we would get auto instead.

[flackr, 2017/06/08 19:35:21]

Ah I see, so if I understand correctly, we're grabbing the iframe's touch action
because it normally wouldn't inherit automatically?

[sunxd, 2017/06/12 17:27:04]

Yes, now I made iframe updates only trigger the recalc, when recalculating the
descendant document, the document will fetch effective touch action actively.

+    if (frame_style) {
+      action &=
+          frame_style->GetEffectiveTouchAction() | TouchAction::kTouchActionPan;

[flackr, 2017/06/07 18:21:47]

Shouldn't we re-enable panning if it was disabled by an ancestor since the
iframe handles the gesture?

[sunxd, 2017/06/08 19:08:11]

Oh I think I should write:

action = frame_style->GetEffectiveTouchAction() | TouchAction::kTouchActionPan

instead.

The parent action of a document element is always empty.

[flackr, 2017/06/08 19:35:20]

Yes, that makes more sense.

[sunxd, 2017/06/09 21:00:35]

Done.

+    }
+  }
+
+  // Apply the adjusted parent effective touch actions.
+  style.SetEffectiveTouchAction(style.GetTouchAction() & action);
+}
+
 void StyleAdjuster::AdjustComputedStyle(
     ComputedStyle& style,
     const ComputedStyle& parent_style,
     const ComputedStyle& layout_parent_style,
     Element* element) {
   if (style.Display() != EDisplay::kNone) {
     if (element && element->IsHTMLElement())
       AdjustStyleForHTMLElement(style, ToHTMLElement(*element));
 
     // Per the spec, position 'static' and 'relative' in the top layer compute
@@ skipping 110 matching lines @@
   if (style.GetPosition() == EPosition::kSticky)
     style.SetSubtreeIsSticky(true);
 
   // If the inherited value of justify-items includes the 'legacy' keyword,
   // 'auto' computes to the the inherited value.  Otherwise, 'auto' computes to
   // 'normal'.
   if (style.JustifyItemsPosition() == kItemPositionAuto) {
     if (parent_style.JustifyItemsPositionType() == kLegacyPosition)
       style.SetJustifyItems(parent_style.JustifyItems());
   }
+
+  AdjustEffectiveTouchAction(style, parent_style, element);
 }
-
 }  // namespace blink