Consolidate all touch/gesture related constants in content

content/browser/renderer_host/input/gesture_event_queue.h

 // Copyright 2014 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 CONTENT_BROWSER_RENDERER_HOST_INPUT_GESTURE_EVENT_QUEUE_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_GESTURE_EVENT_QUEUE_H_
 
 #include <deque>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer/timer.h"
+#include "content/browser/renderer_host/input/tap_suppression_controller.h"
+#include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
+#include "content/browser/renderer_host/input/touchscreen_tap_suppression_controller.h"
 #include "content/common/content_export.h"
 #include "content/port/browser/event_with_latency_info.h"
 #include "content/port/common/input_event_ack_state.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/transform.h"
 
 namespace content {
 class GestureEventQueueTest;
 class InputRouter;
 class MockRenderWidgetHost;
-class TouchpadTapSuppressionController;
-class TouchpadTapSuppressionControllerClient;
-class TouchscreenTapSuppressionController;
 
 // Interface with which the GestureEventQueue can forward gesture events, and
 // dispatch gesture event responses.
 class CONTENT_EXPORT GestureEventQueueClient {
  public:
   virtual ~GestureEventQueueClient() {}
 
   virtual void SendGestureEventImmediately(
       const GestureEventWithLatencyInfo& event) = 0;
 
@@ skipping 18 matching lines @@
 //    as possible and therefore maximize the chance that the event stream can be
 //    handled entirely by the compositor thread.
 // Events in the queue are forwarded to the renderer one by one; i.e., each
 // event is sent after receiving the ACK for previous one. The only exception is
 // that if a GestureScrollUpdate is followed by a GesturePinchUpdate, they are
 // sent together.
 // TODO(rjkroege): Possibly refactor into a filter chain:
 // http://crbug.com/148443.
 class CONTENT_EXPORT GestureEventQueue {
  public:
+  struct CONTENT_EXPORT Config {
+    Config();
+
+    // Controls touchpad-related tap suppression, disabled by default.
+    TapSuppressionController::Config touchpad_tap_suppression_config;
+
+    // Controls touchscreen-related tap suppression, disabled by default.
+    TapSuppressionController::Config touchscreen_tap_suppression_config;
+
+    // Determines whether non-scroll gesture events are "debounced" during an
+    // active scroll sequence, suppressing brief scroll interruptions.
+    // Disabled by default.
+    base::TimeDelta debounce_interval;

[tdresser, 2014/05/01 13:51:56]

A debounce_interval of 0 should be the same as disabling debounce, so we could
get rid of enable_debounce_during_scroll.

It may be clearer this way I suppose.

[jdduke (slow), 2014/05/01 16:44:25]

That's fine with me, I wasn't sure how explicit we wanted to be.

+    bool enable_debounce_during_scroll;
+  };
+
   // Both |client| and |touchpad_client| must outlive the GestureEventQueue.
   GestureEventQueue(GestureEventQueueClient* client,
-                     TouchpadTapSuppressionControllerClient* touchpad_client);
+                    TouchpadTapSuppressionControllerClient* touchpad_client,
+                    const Config& config);
   ~GestureEventQueue();
 
   // Returns |true| if the caller should immediately forward the provided
   // |GestureEventWithLatencyInfo| argument to the renderer.
   // If this function returns false, then the event may be queued and forwared
   // at a later point.
   bool ShouldForward(const GestureEventWithLatencyInfo&);
 
   // Indicates that the caller has received an acknowledgement from the renderer
   // with state |ack_result| and event |type|. May send events if the queue is
@@ skipping 12 matching lines @@
   void ForwardGestureEvent(const GestureEventWithLatencyInfo& gesture_event);
 
   // Whether the queue is expecting a gesture event ack.
   bool ExpectingGestureAck() const;
 
   bool empty() const {
     return coalesced_gesture_events_.empty() &&
            debouncing_deferral_queue_.empty();
   }
 
-  void set_debounce_enabled_for_testing(bool enabled) {
+ void set_debounce_enabled_for_testing(bool enabled) {
     debounce_enabled_ = enabled;
   }
 
   void set_debounce_interval_time_ms_for_testing(int interval_time_ms) {
-    debounce_interval_time_ms_ = interval_time_ms;
+    debounce_interval_ = base::TimeDelta::FromMilliseconds(interval_time_ms);
   }
 
  private:
   friend class GestureEventQueueTest;
   friend class MockRenderWidgetHost;
 
   // TODO(mohsen): There are a bunch of ShouldForward.../ShouldDiscard...
   // methods that are getting confusing. This should be somehow fixed. Maybe
   // while refactoring GEQ: http://crbug.com/148443.
 
@@ skipping 66 matching lines @@
 
   // True if two related gesture events were sent before without waiting
   // for an ACK, so the next gesture ACK should be ignored.
   bool ignore_next_ack_;
 
   // An object tracking the state of touchpad on the delivery of mouse events to
   // the renderer to filter mouse immediately after a touchpad fling canceling
   // tap.
   // TODO(mohsen): Move touchpad tap suppression out of GestureEventQueue since
   // GEQ is meant to only be used for touchscreen gesture events.
-  scoped_ptr<TouchpadTapSuppressionController>
-      touchpad_tap_suppression_controller_;
+  TouchpadTapSuppressionController touchpad_tap_suppression_controller_;
 
   // An object tracking the state of touchscreen on the delivery of gesture tap
   // events to the renderer to filter taps immediately after a touchscreen fling
   // canceling tap.
-  scoped_ptr<TouchscreenTapSuppressionController>
-      touchscreen_tap_suppression_controller_;
+  TouchscreenTapSuppressionController touchscreen_tap_suppression_controller_;
 
   typedef std::deque<GestureEventWithLatencyInfo> GestureQueue;
 
   // Queue of coalesced gesture events not yet sent to the renderer. If
   // |ignore_next_ack_| is false, then the event at the front of the queue has
   // been sent and is awaiting an ACK, and all other events have yet to be sent.
   // If |ignore_next_ack_| is true, then the two events at the front of the
   // queue have been sent, and the second is awaiting an ACK. All other events
   // have yet to be sent.
   GestureQueue coalesced_gesture_events_;
 
   // Timer to release a previously deferred gesture event.
   base::OneShotTimer<GestureEventQueue> debounce_deferring_timer_;
 
   // Queue of events that have been deferred for debounce.
   GestureQueue debouncing_deferral_queue_;
 
   // Time window in which to debounce scroll/fling ends.
-  // TODO(rjkroege): Make this dynamically configurable.
-  int debounce_interval_time_ms_;
+  base::TimeDelta debounce_interval_;
 
   // Whether scroll-ending events should be deferred when a scroll is active.
   // Defaults to true.
   bool debounce_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_GESTURE_EVENT_QUEUE_H_