Implement Wheel Gesture Scrolling on OSX.

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 "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
@@ skipping 81 matching lines @@
         : thread(SCROLL_ON_IMPL_THREAD),
           main_thread_scrolling_reasons(
               MainThreadScrollingReason::kNotScrollingOnMain) {}
     ScrollStatus(ScrollThread thread, uint32_t main_thread_scrolling_reasons)
         : thread(thread),
           main_thread_scrolling_reasons(main_thread_scrolling_reasons) {}
     ScrollThread thread;
     uint32_t main_thread_scrolling_reasons;
   };
 
-  enum ScrollInputType { GESTURE, WHEEL, ANIMATED_WHEEL, NON_BUBBLING_GESTURE };
+  enum ScrollInputType {
+    GESTURE,  // TODO(dtapuska): Remove this and just use TOUCHSCREEN.

[tdresser, 2016/03/08 14:28:52]

I'm a fan of giving TODOs associated bugs and referencing them in the comments -
it makes it easier to tell that you've done all the associated cleanup.

[dtapuska, 2016/03/08 20:31:49]

Done.

+    TOUCHSCREEN = GESTURE,
+    WHEEL,
+    ANIMATED_WHEEL,
+    NON_BUBBLING_GESTURE
+  };
 
   // 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.
   virtual ScrollStatus ScrollBegin(ScrollState* scroll_state,
                                    ScrollInputType type) = 0;
 
   // Similar to ScrollBegin, except the hit test is skipped and scroll always
   // targets at the root layer.
   virtual ScrollStatus RootScrollBegin(ScrollState* scroll_state,
                                        ScrollInputType type) = 0;
+
+  // Returns SCROLL_ON_IMPL_THREAD if a layer is actively being scrolled or
+  // a subsequent call to ScrollAnimated can begin on the impl thread.
+  virtual ScrollStatus ScrollAnimatedBegin(
+      const gfx::Point& viewport_point) = 0;
+
   virtual ScrollStatus ScrollAnimated(const gfx::Point& viewport_point,
                                       const gfx::Vector2dF& scroll_delta) = 0;
 
   // Scroll the layer selected by |ScrollBegin| by given |scroll_state| delta.
   // Internally, the delta is transformed to local layer's coordinate space for
   // scrolls gestures that are direct manipulation (e.g. touch). If there is no
   // room to move the layer in the requested direction, its first ancestor layer
   // that can be scrolled will be moved instead. The return value's |did_scroll|
   // field is set to false if no layer can be moved in the requested direction
   // at all, and set to true if any layer is moved. If the scroll delta hits the
   // root layer, and the layer can no longer move, the root overscroll
   // accumulated within this ScrollBegin() scope is reported in the return
   // value's |accumulated_overscroll| field. Should only be called if
   // ScrollBegin() returned SCROLL_STARTED.
   virtual InputHandlerScrollResult ScrollBy(ScrollState* scroll_state) = 0;
 
   virtual bool ScrollVerticallyByPage(const gfx::Point& viewport_point,
                                       ScrollDirection direction) = 0;
 
-  // Returns SCROLL_STARTED if a layer was being actively being scrolled,
+  // Returns SCROLL_STARTED if a layer was actively being scrolled,
   // SCROLL_IGNORED if not.
   virtual ScrollStatus FlingScrollBegin() = 0;
 
   virtual void MouseMoveAt(const gfx::Point& mouse_position) = 0;
 
   // Stop scrolling the selected layer. Should only be called if ScrollBegin()
   // returned SCROLL_STARTED.
   virtual void ScrollEnd(ScrollState* scroll_state) = 0;
 
   // Requests a callback to UpdateRootLayerStateForSynchronousInputHandler()
@@ skipping 41 matching lines @@
   InputHandler() {}
   virtual ~InputHandler() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InputHandler);
 };
 
 }  // namespace cc
 
 #endif  // CC_INPUT_INPUT_HANDLER_H_