Make touch events uncancelable during fling when they are on the current active scroll layer

cc/input/input_handler.h

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CC_INPUT_INPUT_HANDLER_H_
 #define CC_INPUT_INPUT_HANDLER_H_
 
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 86 matching lines @@
     ScrollThread thread;
     uint32_t main_thread_scrolling_reasons;
   };
 
   enum ScrollInputType {
     TOUCHSCREEN,
     WHEEL,
     NON_BUBBLING_GESTURE
   };
 
+  enum class TouchStartEventListenerType {
+    NO_HANDLER,
+    HANDLER,
+    HANDLER_ON_SCROLLING_LAYER
+  };
+
   // Binds a client to this handler to receive notifications. Only one client
   // can be bound to an InputHandler. The client must live at least until the
   // handler calls WillShutdown() on the client.
   virtual void BindToClient(InputHandlerClient* client) = 0;
 
   // Selects a layer to be scrolled using the |scroll_state| start position.
   // Returns SCROLL_STARTED if the layer at the coordinates can be scrolled,
   // SCROLL_ON_MAIN_THREAD if the scroll event should instead be delegated to
   // the main thread, or SCROLL_IGNORED if there is nothing to be scrolled at
   // the given coordinates.
@@ skipping 63 matching lines @@
   // Returns true if there is an active scroll on the viewport.
   virtual bool IsCurrentlyScrollingViewport() const = 0;
 
   // Whether the layer under |viewport_point| is the currently scrolling layer.
   virtual bool IsCurrentlyScrollingLayerAt(const gfx::Point& viewport_point,
                                            ScrollInputType type) const = 0;
 
   virtual EventListenerProperties GetEventListenerProperties(
       EventListenerClass event_class) const = 0;
 
-  // Whether the page should be given the opportunity to suppress scrolling by
-  // consuming touch events that started at |viewport_point|.
-  virtual bool DoTouchEventsBlockScrollAt(const gfx::Point& viewport_point) = 0;
+  // It returns the type of event listener at the given viewport point. Such as
+  // if the page has a touch handler or not, and whether the page should
+  // suppress scrolling by consuming touch events that started at
+  // |viewport_point|.

[tdresser, 2016/11/28 14:18:47]

This comment is confusing.

This doesn't indicate whether the page "should" suppress scrolling, only if the
page should have the opportunity to suppress scrolling.

Whether the page has a touch handler or not is equivalent to whether it has the
opportunity to prevent scrolling, and this comment phrases it as though this is
separate information.

How is this comment different from the previous comment?

[lanwei, 2016/12/01 22:44:18]

Done.

+  virtual TouchStartEventListenerType EventListenerTypeForTouchStartAt(
+      const gfx::Point& viewport_point) = 0;
 
   // Calling CreateLatencyInfoSwapPromiseMonitor() to get a scoped
   // LatencyInfoSwapPromiseMonitor. During the life time of the
   // LatencyInfoSwapPromiseMonitor, if SetNeedsRedraw() or SetNeedsRedrawRect()
   // is called on LayerTreeHostImpl, the original latency info will be turned
   // into a LatencyInfoSwapPromise.
   virtual std::unique_ptr<SwapPromiseMonitor>
   CreateLatencyInfoSwapPromiseMonitor(ui::LatencyInfo* latency) = 0;
 
   virtual ScrollElasticityHelper* CreateScrollElasticityHelper() = 0;
 
   // Called by the single-threaded UI Compositor to get or set the scroll offset
   // on the impl side. Retruns false if |layer_id| isn't in the active tree.
   virtual bool GetScrollOffsetForLayer(int layer_id,
                                        gfx::ScrollOffset* offset) = 0;
   virtual bool ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset) = 0;
 
  protected:
   InputHandler() {}
   virtual ~InputHandler() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InputHandler);
 };
 
 }  // namespace cc
 
 #endif  // CC_INPUT_INPUT_HANDLER_H_