input: Make the OverscrollController less intrusive, and some code cleanup.

content/browser/renderer_host/input/buffered_input_router.cc

 // Copyright 2013 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.
 
 #include "content/browser/renderer_host/input/buffered_input_router.h"
 
 #include "base/auto_reset.h"
 #include "content/browser/renderer_host/input/browser_input_event.h"
 #include "content/browser/renderer_host/input/input_ack_handler.h"
 #include "content/browser/renderer_host/input/input_queue.h"
@@ skipping 13 matching lines @@
 namespace content {
 
 BufferedInputRouter::BufferedInputRouter(IPC::Sender* sender,
                                          InputRouterClient* client,
                                          InputAckHandler* ack_handler,
                                          int routing_id)
     : client_(client),
       ack_handler_(ack_handler),
       sender_(sender),
       routing_id_(routing_id),
-      queued_gesture_count_(0),
       has_touch_handler_(false),
       queued_touch_count_(0),
       input_queue_override_(NULL),
       next_input_id_(1),
       in_flight_packet_id_(0) {
   input_queue_.reset(new InputQueue(this));
 }
 
 BufferedInputRouter::~BufferedInputRouter() {}
 
@@ skipping 37 matching lines @@
   if (event_id) {
     DCHECK(queued_key_map_.find(event_id) == queued_key_map_.end());
     queued_key_map_[event_id] = key_event;
   }
 }
 
 void BufferedInputRouter::SendGestureEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (!client_->OnSendGestureEvent(gesture_event))
     return;
-  if (QueueWebEvent(gesture_event.event, gesture_event.latency, false))
-    ++queued_gesture_count_;
+  QueueWebEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 void BufferedInputRouter::SendTouchEvent(
     const TouchEventWithLatencyInfo& touch_event) {
   if (!client_->OnSendTouchEvent(touch_event))
     return;
   if (QueueWebEvent(touch_event.event, touch_event.latency, false))
     ++queued_touch_count_;
 }
 
@@ skipping 96 matching lines @@
 
 bool BufferedInputRouter::ShouldForwardTouchEvent() const {
   return has_touch_handler_ && queued_touch_count_ > 0;
 }
 
 bool BufferedInputRouter::ShouldForwardGestureEvent(
     const GestureEventWithLatencyInfo& touch_event) const {
   return true;
 }
 
-bool BufferedInputRouter::HasQueuedGestureEvents() const {
-  return queued_gesture_count_ > 0;
-}
-
 void BufferedInputRouter::OnWebInputEventAck(
     int64 event_id,
     const WebKit::WebInputEvent& web_event,
     const ui::LatencyInfo& latency_info,
     InputEventAckState acked_result,
     bool ack_from_input_queue) {
   if (WebInputEvent::isKeyboardEventType(web_event.type)) {
     if (ack_from_input_queue) {
       KeyMap::iterator key_it = queued_key_map_.find(event_id);
       DCHECK(key_it != queued_key_map_.end());
@@ skipping 14 matching lines @@
   } else if (WebInputEvent::isTouchEventType(web_event.type)) {
     if (ack_from_input_queue) {
       DCHECK_GT(queued_touch_count_, 0);
       --queued_touch_count_;
     }
     ack_handler_->OnTouchEventAck(
         TouchEventWithLatencyInfo(static_cast<const WebTouchEvent&>(web_event),
                                   latency_info),
         acked_result);
   } else if (WebInputEvent::isGestureEventType(web_event.type)) {
-    if (ack_from_input_queue) {
-      DCHECK_GT(queued_gesture_count_, 0);
-      --queued_gesture_count_;
-    }
     ack_handler_->OnGestureEventAck(
         static_cast<const WebGestureEvent&>(web_event), acked_result);
   } else
     NOTREACHED() << "Unexpected WebInputEvent in OnWebInputEventAck";
 }
 
 void BufferedInputRouter::OnEventPacketAck(
     int64 packet_id,
     const InputEventDispositions& dispositions) {
   TRACE_EVENT2("input", "BufferedInputRouter::OnEventPacketAck",
@@ skipping 75 matching lines @@
     default:
       break;
   };
 
   return false;
 }
 
 int64 BufferedInputRouter::NextInputID() { return next_input_id_++; }
 
 }  // namespace content