Eager Gesture Recognizer (WIP)

content/browser/renderer_host/input/input_router_impl.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/input_router_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 199 matching lines @@
     if (controller)
       controller->DiscardingGestureEvent(gesture_event.event);
     return;
   }
 
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 void InputRouterImpl::SendTouchEvent(
     const TouchEventWithLatencyInfo& touch_event) {
+  LOG(ERROR) << "Queueing touch event";
   touch_event_queue_->QueueEvent(touch_event);
 }
 
 // Forwards MouseEvent without passing it through
 // TouchpadTapSuppressionController.
 void InputRouterImpl::SendMouseEventImmediately(
     const MouseEventWithLatencyInfo& mouse_event) {
   // Avoid spamming the renderer with mouse move events.  It is important
   // to note that WM_MOUSEMOVE events are anyways synthetic, but since our
   // thread is able to rapidly consume WM_MOUSEMOVE events, we may get way
   // more WM_MOUSEMOVE events than we wish to send to the renderer.
   if (mouse_event.event.type == WebInputEvent::MouseMove) {
     if (mouse_move_pending_) {
       if (!next_mouse_move_)
         next_mouse_move_.reset(new MouseEventWithLatencyInfo(mouse_event));
       else
         next_mouse_move_->CoalesceWith(mouse_event);
       return;
     }
     mouse_move_pending_ = true;
   }
 
   FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency, false);
 }
 
 void InputRouterImpl::SendTouchEventImmediately(
     const TouchEventWithLatencyInfo& touch_event) {
+  LOG(ERROR) << "Skipping Queue";
   FilterAndSendWebInputEvent(touch_event.event, touch_event.latency, false);
 }
 
 void InputRouterImpl::SendGestureEventImmediately(
     const GestureEventWithLatencyInfo& gesture_event) {
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 const NativeWebKeyboardEvent* InputRouterImpl::GetLastKeyboardEvent() const {
   if (key_queue_.empty())
     return NULL;
   return &key_queue_.front();
 }
 
 bool InputRouterImpl::ShouldForwardTouchEvent() const {
+  if (!has_touch_handler_)
+    LOG(ERROR) << "No touch handler";
   // Always send a touch event if the renderer has a touch-event handler. It is
   // possible that a renderer stops listening to touch-events while there are
   // still events in the touch-queue. In such cases, the new events should still
   // get into the queue.
   return has_touch_handler_ || !touch_event_queue_->empty();
 }
 
 void InputRouterImpl::OnViewUpdated(int view_flags) {
   bool fixed_page_scale = (view_flags & FIXED_PAGE_SCALE) != 0;
   bool mobile_viewport = (view_flags & MOBILE_VIEWPORT) != 0;
@@ skipping 17 matching lines @@
   IPC_END_MESSAGE_MAP()
 
   if (!message_is_ok)
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
 
   return handled;
 }
 
 void InputRouterImpl::OnTouchEventAck(const TouchEventWithLatencyInfo& event,
                                       InputEventAckState ack_result) {
+  LOG(ERROR) << "Touch Event Ack";
   ack_handler_->OnTouchEventAck(event, ack_result);
 }
 
 void InputRouterImpl::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   ProcessAckForOverscroll(event.event, ack_result);
   ack_handler_->OnGestureEventAck(event, ack_result);
 }
 
@@ skipping 415 matching lines @@
       break;
   }
 }
 
 bool InputRouterImpl::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content