Remove the blocking touch handlers for the input[type=range] and add touch-action instead

third_party/WebKit/Source/core/html/shadow/SliderThumbElement.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 16 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/shadow/SliderThumbElement.h"
 
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/events/MouseEvent.h"
+#include "core/events/TouchEvent.h"
+#include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/forms/StepRange.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/shadow/ShadowElementNames.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutSliderContainer.h"
 #include "core/layout/LayoutSliderThumb.h"
 #include "core/layout/LayoutTheme.h"
 
@@ skipping 245 matching lines @@
         return mediaSliderThumbShadowPartId();
     default:
         return sliderThumbShadowPartId();
     }
 }
 
 // --------------------------------
 
 inline SliderContainerElement::SliderContainerElement(Document& document)
     : HTMLDivElement(document)
+    , m_hasTouchEventHandler(false)
+    , m_touchStarted(false)
+    , m_slidingDirection(NoMove)
 {
 }
 
 DEFINE_NODE_FACTORY(SliderContainerElement)
 
+HTMLInputElement* SliderContainerElement::hostInput() const
+{
+    return toHTMLInputElement(shadowHost());
+}
+
 LayoutObject* SliderContainerElement::createLayoutObject(const ComputedStyle&)
 {
     return new LayoutSliderContainer(this);
 }
 
+void SliderContainerElement::defaultEventHandler(Event* event)
+{
+    if (event->isTouchEvent()) {
+        handleTouchEvent(toTouchEvent(event));
+        return;
+    }
+}
+
+void SliderContainerElement::handleTouchEvent(TouchEvent* event)
+{
+    HTMLInputElement* input = toHTMLInputElement(shadowHost());

[tkent, 2016/08/22 06:00:48]

HTMLInputElement* input = hostInput();

+    if (input->isDisabledOrReadOnly())
+        return;
+
+    if (event->type() == EventTypeNames::touchend) {
+        input->dispatchFormControlChangeEvent();
+        event->setDefaultHandled();
+        m_slidingDirection = NoMove;
+        m_touchStarted = false;
+        return;
+    }
+
+    if (!canSlide()) {
+        return;
+    }
+
+    TouchList* touches = event->targetTouches();
+    SliderThumbElement* thumb = toSliderThumbElement(input->userAgentShadowRoot()->getElementById(ShadowElementNames::sliderThumb()));

[tkent, 2016/08/22 06:00:48]

toSliderThumbElement(treeScope()->getElementById(ShadowElementNames::sliderThumb()))

is simpler.

+    if (touches->length() == 1) {
+        if (event->type() == EventTypeNames::touchstart) {
+            m_startPoint = touches->item(0)->absoluteLocation();
+            m_slidingDirection = NoMove;
+            m_touchStarted = true;
+            thumb->setPositionFromPoint(touches->item(0)->absoluteLocation());
+        } else if (m_touchStarted) {
+            LayoutPoint currentPoint = touches->item(0)->absoluteLocation();
+            if (m_slidingDirection == NoMove) {
+                m_slidingDirection = getDirection(currentPoint, m_startPoint);
+            }
+            if (m_slidingDirection != NoMove && canSlide()) {

[tkent, 2016/08/22 06:00:48]

m_slidingDirection==NoMove was already check.  So this line should be |} else if
...|

    } else if (canSlide()) {

Also, canSlide() was already checked at line 344.

+                thumb->setPositionFromPoint(touches->item(0)->absoluteLocation());
+                event->setDefaultHandled();
+            }
+        }
+    }
+}
+
+SliderContainerElement::Direction SliderContainerElement::getDirection(LayoutPoint& point1, LayoutPoint& point2)
+{
+    if (point1 == point2) {
+        return NoMove;
+    }
+    if ((point1.x() - point2.x()).abs() >= (point1.y() - point2.y()).abs()) {
+        return Horizontal;
+    }
+    return Vertical;
+}
+
+bool SliderContainerElement::canSlide()
+{
+    DCHECK(hostInput()->layoutObject());
+    const ComputedStyle& sliderStyle = hostInput()->layoutObject()->styleRef();
+    const TransformOperations& transforms = sliderStyle.transform();
+    int transformSize = transforms.size();
+    if (transformSize > 0) {
+        for (int i = 0; i < transformSize; ++i) {
+            if (transforms.at(i)->type() == TransformOperation::Rotate) {
+                return true;
+            }
+        }
+    }
+    if ((m_slidingDirection == Vertical && sliderStyle.appearance() == SliderHorizontalPart) || (m_slidingDirection == Horizontal && sliderStyle.appearance() == SliderVerticalPart)) {
+        return false;
+    }
+    return true;
+}
+
 const AtomicString& SliderContainerElement::shadowPseudoId() const
 {
     DEFINE_STATIC_LOCAL(const AtomicString, mediaSliderContainer, ("-webkit-media-slider-container"));
     DEFINE_STATIC_LOCAL(const AtomicString, sliderContainer, ("-webkit-slider-container"));
 
     if (!shadowHost() || !shadowHost()->layoutObject())
         return sliderContainer;
 
     const ComputedStyle& sliderStyle = shadowHost()->layoutObject()->styleRef();
     switch (sliderStyle.appearance()) {
     case MediaSliderPart:
     case MediaSliderThumbPart:
     case MediaVolumeSliderPart:
     case MediaVolumeSliderThumbPart:
     case MediaFullScreenVolumeSliderPart:
     case MediaFullScreenVolumeSliderThumbPart:
         return mediaSliderContainer;
     default:
         return sliderContainer;
     }
 }
 
+void SliderContainerElement::updateTouchEventHandlerRegistry()
+{
+    if (m_hasTouchEventHandler) {
+        return;
+    }
+    if (document().frameHost() && document().lifecycle().state() < DocumentLifecycle::Stopping) {
+        EventHandlerRegistry& registry = document().frameHost()->eventHandlerRegistry();
+        registry.didAddEventHandler(*this, EventHandlerRegistry::TouchStartOrMoveEventPassive);
+        m_hasTouchEventHandler = true;
+    }
+}
+
+void SliderContainerElement::didMoveToNewDocument(Document& oldDocument)
+{
+    updateTouchEventHandlerRegistry();
+    HTMLElement::didMoveToNewDocument(oldDocument);
+}
+
+void SliderContainerElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
+{
+    HTMLElement::parseAttribute(name, oldValue, value);
+    updateTouchEventHandlerRegistry();

[tkent, 2016/08/22 06:00:48]

I think we can move this to RangeInputType::createShadowSubtree(), and remove
the parseAttribute() override.

+}
+
+void SliderContainerElement::removeAllEventListeners()
+{
+    Node::removeAllEventListeners();
+    m_hasTouchEventHandler = false;
+}
+
 } // namespace blink