content/browser/renderer_host/input/input_router_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/input/input_router_impl.h"
   6
   7 #include <math.h>
   8
   9 #include "base/auto_reset.h"
  10 #include "base/command_line.h"
  11 #include "base/metrics/histogram.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "content/browser/renderer_host/input/gesture_event_queue.h"
  14 #include "content/browser/renderer_host/input/input_ack_handler.h"
  15 #include "content/browser/renderer_host/input/input_router_client.h"
  16 #include "content/browser/renderer_host/input/touch_event_queue.h"
  17 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
  18 #include "content/common/content_constants_internal.h"
  19 #include "content/common/edit_command.h"
  20 #include "content/common/input/input_event_ack_state.h"
  21 #include "content/common/input/touch_action.h"
  22 #include "content/common/input/web_touch_event_traits.h"
  23 #include "content/common/input_messages.h"
  24 #include "content/common/view_messages.h"
  25 #include "content/public/browser/notification_service.h"
  26 #include "content/public/browser/notification_types.h"
  27 #include "content/public/browser/user_metrics.h"
  28 #include "content/public/common/content_switches.h"
  29 #include "ipc/ipc_sender.h"
  30 #include "ui/events/event.h"
  31 #include "ui/events/keycodes/keyboard_codes.h"
  32
  33 using base::Time;
  34 using base::TimeDelta;
  35 using base::TimeTicks;
  36 using blink::WebGestureEvent;
  37 using blink::WebInputEvent;
  38 using blink::WebKeyboardEvent;
  39 using blink::WebMouseEvent;
  40 using blink::WebMouseWheelEvent;
  41
  42 namespace content {
  43 namespace {
  44
  45 const char* GetEventAckName(InputEventAckState ack_result) {
  46   switch(ack_result) {
  47     case INPUT_EVENT_ACK_STATE_UNKNOWN: return "UNKNOWN";
  48     case INPUT_EVENT_ACK_STATE_CONSUMED: return "CONSUMED";
  49     case INPUT_EVENT_ACK_STATE_NOT_CONSUMED: return "NOT_CONSUMED";
  50     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS: return "NO_CONSUMER_EXISTS";
  51     case INPUT_EVENT_ACK_STATE_IGNORED: return "IGNORED";
  52   }
  53   DLOG(WARNING) << "Unhandled InputEventAckState in GetEventAckName.";
  54   return "";
  55 }
  56
  57 } // namespace
  58
  59 InputRouterImpl::Config::Config() {
  60 }
  61
  62 InputRouterImpl::InputRouterImpl(IPC::Sender* sender,
  63                                  InputRouterClient* client,
  64                                  InputAckHandler* ack_handler,
  65                                  int routing_id,
  66                                  const Config& config)
  67     : sender_(sender),
  68       client_(client),
  69       ack_handler_(ack_handler),
  70       routing_id_(routing_id),
  71       select_range_pending_(false),
  72       move_caret_pending_(false),
  73       mouse_move_pending_(false),
  74       mouse_wheel_pending_(false),
  75       current_view_flags_(0),
  76       current_ack_source_(ACK_SOURCE_NONE),
  77       flush_requested_(false),
  78       touch_event_queue_(this, config.touch_config),
  79       gesture_event_queue_(this, this, config.gesture_config) {
  80   DCHECK(sender);
  81   DCHECK(client);
  82   DCHECK(ack_handler);
  83   UpdateTouchAckTimeoutEnabled();
  84 }
  85
  86 InputRouterImpl::~InputRouterImpl() {}
  87
  88 void InputRouterImpl::Flush() {
  89   flush_requested_ = true;
  90   SignalFlushedIfNecessary();
  91 }
  92
  93 bool InputRouterImpl::SendInput(scoped_ptr<IPC::Message> message) {
  94   DCHECK(IPC_MESSAGE_ID_CLASS(message->type()) == InputMsgStart);
  95   switch (message->type()) {
  96     // Check for types that require an ACK.
  97     case InputMsg_SelectRange::ID:
  98       return SendSelectRange(message.Pass());
  99     case InputMsg_MoveCaret::ID:
 100       return SendMoveCaret(message.Pass());
 101     case InputMsg_HandleInputEvent::ID:
 102       NOTREACHED() << "WebInputEvents should never be sent via SendInput.";
 103       return false;
 104     default:
 105       return Send(message.release());
 106   }
 107 }
 108
 109 void InputRouterImpl::SendMouseEvent(
 110     const MouseEventWithLatencyInfo& mouse_event) {
 111   if (mouse_event.event.type == WebInputEvent::MouseDown &&
 112       gesture_event_queue_.GetTouchpadTapSuppressionController()->
 113           ShouldDeferMouseDown(mouse_event))
 114       return;
 115   if (mouse_event.event.type == WebInputEvent::MouseUp &&
 116       gesture_event_queue_.GetTouchpadTapSuppressionController()->
 117           ShouldSuppressMouseUp())
 118       return;
 119
 120   SendMouseEventImmediately(mouse_event);
 121 }
 122
 123 void InputRouterImpl::SendWheelEvent(
 124     const MouseWheelEventWithLatencyInfo& wheel_event) {
 125   SendWheelEvent(QueuedWheelEvent(wheel_event, false));
 126 }
 127
 128 void InputRouterImpl::SendWheelEvent(const QueuedWheelEvent& wheel_event) {
 129   if (mouse_wheel_pending_) {
 130     // If there's already a mouse wheel event waiting to be sent to the
 131     // renderer, add the new deltas to that event. Not doing so (e.g., by
 132     // dropping the old event, as for mouse moves) results in very slow
 133     // scrolling on the Mac (on which many, very small wheel events are sent).
 134     // Note that we can't coalesce wheel events for pinches because the GEQ
 135     // expects one ACK for each (but it's fine to coalesce non-pinch wheels
 136     // into a pinch one).  Note that the GestureEventQueue ensures we only
 137     // ever have a single pinch event queued here.
 138     if (coalesced_mouse_wheel_events_.empty() ||
 139         wheel_event.synthesized_from_pinch ||
 140         !coalesced_mouse_wheel_events_.back().event.CanCoalesceWith(
 141             wheel_event.event)) {
 142       coalesced_mouse_wheel_events_.push_back(wheel_event);
 143     } else {
 144       coalesced_mouse_wheel_events_.back().event.CoalesceWith(
 145           wheel_event.event);
 146     }
 147     return;
 148   }
 149
 150   mouse_wheel_pending_ = true;
 151   current_wheel_event_ = wheel_event;
 152
 153   LOCAL_HISTOGRAM_COUNTS_100("Renderer.WheelQueueSize",
 154                              coalesced_mouse_wheel_events_.size());
 155
 156   FilterAndSendWebInputEvent(
 157       wheel_event.event.event, wheel_event.event.latency, false);
 158 }
 159
 160 void InputRouterImpl::SendKeyboardEvent(const NativeWebKeyboardEvent& key_event,
 161                                         const ui::LatencyInfo& latency_info,
 162                                         bool is_keyboard_shortcut) {
 163   // Put all WebKeyboardEvent objects in a queue since we can't trust the
 164   // renderer and we need to give something to the HandleKeyboardEvent
 165   // handler.
 166   key_queue_.push_back(key_event);
 167   LOCAL_HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 168
 169   gesture_event_queue_.FlingHasBeenHalted();
 170
 171   // Only forward the non-native portions of our event.
 172   FilterAndSendWebInputEvent(key_event, latency_info, is_keyboard_shortcut);
 173 }
 174
 175 void InputRouterImpl::SendGestureEvent(
 176     const GestureEventWithLatencyInfo& original_gesture_event) {
 177   input_stream_validator_.Validate(original_gesture_event.event);
 178
 179   GestureEventWithLatencyInfo gesture_event(original_gesture_event);
 180
 181   if (touch_action_filter_.FilterGestureEvent(&gesture_event.event))
 182     return;
 183
 184   if (gesture_event.event.sourceDevice == blink::WebGestureDeviceTouchscreen)
 185     touch_event_queue_.OnGestureScrollEvent(gesture_event);
 186
 187   if (!gesture_event_queue_.ShouldForward(gesture_event))
 188     return;
 189
 190   SendGestureEventImmediately(gesture_event);
 191 }
 192
 193 void InputRouterImpl::SendTouchEvent(
 194     const TouchEventWithLatencyInfo& touch_event) {
 195   input_stream_validator_.Validate(touch_event.event);
 196   touch_event_queue_.QueueEvent(touch_event);
 197 }
 198
 199 // Forwards MouseEvent without passing it through
 200 // TouchpadTapSuppressionController.
 201 void InputRouterImpl::SendMouseEventImmediately(
 202     const MouseEventWithLatencyInfo& mouse_event) {
 203   // Avoid spamming the renderer with mouse move events.  It is important
 204   // to note that WM_MOUSEMOVE events are anyways synthetic, but since our
 205   // thread is able to rapidly consume WM_MOUSEMOVE events, we may get way
 206   // more WM_MOUSEMOVE events than we wish to send to the renderer.
 207   if (mouse_event.event.type == WebInputEvent::MouseMove) {
 208     if (mouse_move_pending_) {
 209       if (!next_mouse_move_)
 210         next_mouse_move_.reset(new MouseEventWithLatencyInfo(mouse_event));
 211       else
 212         next_mouse_move_->CoalesceWith(mouse_event);
 213       return;
 214     }
 215     mouse_move_pending_ = true;
 216   }
 217
 218   FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency, false);
 219 }
 220
 221 void InputRouterImpl::SendTouchEventImmediately(
 222     const TouchEventWithLatencyInfo& touch_event) {
 223   if (WebTouchEventTraits::IsTouchSequenceStart(touch_event.event)) {
 224     touch_action_filter_.ResetTouchAction();
 225     // Note that if the previous touch-action was TOUCH_ACTION_NONE, enabling
 226     // the timeout here will not take effect until the *following* touch
 227     // sequence.  This is a desirable side-effect, giving the renderer a chance
 228     // to send a touch-action response without racing against the ack timeout.
 229     UpdateTouchAckTimeoutEnabled();
 230   }
 231
 232   FilterAndSendWebInputEvent(touch_event.event, touch_event.latency, false);
 233 }
 234
 235 void InputRouterImpl::SendGestureEventImmediately(
 236     const GestureEventWithLatencyInfo& gesture_event) {
 237   if (gesture_event.event.type == WebInputEvent::GesturePinchUpdate &&
 238       gesture_event.event.sourceDevice == blink::WebGestureDeviceTouchpad) {
 239     SendSyntheticWheelEventForPinch(gesture_event);
 240     return;
 241   }
 242
 243   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 244 }
 245
 246 const NativeWebKeyboardEvent* InputRouterImpl::GetLastKeyboardEvent() const {
 247   if (key_queue_.empty())
 248     return NULL;
 249   return &key_queue_.front();
 250 }
 251
 252 bool InputRouterImpl::ShouldForwardTouchEvent() const {
 253   // Always send a touch event if the renderer has a touch-event handler or
 254   // there are pending touch events.
 255   return touch_event_queue_.has_handlers() || !touch_event_queue_.empty();
 256 }
 257
 258 void InputRouterImpl::OnViewUpdated(int view_flags) {
 259   current_view_flags_ = view_flags;
 260
 261   // A fixed page scale or mobile viewport should disable the touch ack timeout.
 262   UpdateTouchAckTimeoutEnabled();
 263 }
 264
 265 bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
 266   bool handled = true;
 267   IPC_BEGIN_MESSAGE_MAP(InputRouterImpl, message)
 268     IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
 269     IPC_MESSAGE_HANDLER(InputHostMsg_DidOverscroll, OnDidOverscroll)
 270     IPC_MESSAGE_HANDLER(ViewHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
 271     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectRange_ACK, OnSelectRangeAck)
 272     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
 273                         OnHasTouchEventHandlers)
 274     IPC_MESSAGE_HANDLER(InputHostMsg_SetTouchAction,
 275                         OnSetTouchAction)
 276     IPC_MESSAGE_UNHANDLED(handled = false)
 277   IPC_END_MESSAGE_MAP()
 278
 279   return handled;
 280 }
 281
 282 void InputRouterImpl::OnTouchEventAck(const TouchEventWithLatencyInfo& event,
 283                                       InputEventAckState ack_result) {
 284   // Touchstart events sent to the renderer indicate a new touch sequence, but
 285   // in some cases we may filter out sending the touchstart - catch those here.
 286   if (WebTouchEventTraits::IsTouchSequenceStart(event.event) &&
 287       ack_result == INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS) {
 288     touch_action_filter_.ResetTouchAction();
 289     UpdateTouchAckTimeoutEnabled();
 290   }
 291   ack_handler_->OnTouchEventAck(event, ack_result);
 292 }
 293
 294 void InputRouterImpl::OnGestureEventAck(
 295     const GestureEventWithLatencyInfo& event,
 296     InputEventAckState ack_result) {
 297   touch_event_queue_.OnGestureEventAck(event, ack_result);
 298   ack_handler_->OnGestureEventAck(event, ack_result);
 299 }
 300
 301 bool InputRouterImpl::SendSelectRange(scoped_ptr<IPC::Message> message) {
 302   DCHECK(message->type() == InputMsg_SelectRange::ID);
 303   if (select_range_pending_) {
 304     next_selection_range_ = message.Pass();
 305     return true;
 306   }
 307
 308   select_range_pending_ = true;
 309   return Send(message.release());
 310 }
 311
 312 bool InputRouterImpl::SendMoveCaret(scoped_ptr<IPC::Message> message) {
 313   DCHECK(message->type() == InputMsg_MoveCaret::ID);
 314   if (move_caret_pending_) {
 315     next_move_caret_ = message.Pass();
 316     return true;
 317   }
 318
 319   move_caret_pending_ = true;
 320   return Send(message.release());
 321 }
 322
 323 bool InputRouterImpl::Send(IPC::Message* message) {
 324   return sender_->Send(message);
 325 }
 326
 327 void InputRouterImpl::FilterAndSendWebInputEvent(
 328     const WebInputEvent& input_event,
 329     const ui::LatencyInfo& latency_info,
 330     bool is_keyboard_shortcut) {
 331   TRACE_EVENT1("input",
 332                "InputRouterImpl::FilterAndSendWebInputEvent",
 333                "type",
 334                WebInputEventTraits::GetName(input_event.type));
 335
 336   // Any input event cancels a pending mouse move event.
 337   next_mouse_move_.reset();
 338
 339   OfferToHandlers(input_event, latency_info, is_keyboard_shortcut);
 340 }
 341
 342 void InputRouterImpl::OfferToHandlers(const WebInputEvent& input_event,
 343                                       const ui::LatencyInfo& latency_info,
 344                                       bool is_keyboard_shortcut) {
 345   output_stream_validator_.Validate(input_event);
 346
 347   if (OfferToClient(input_event, latency_info))
 348     return;
 349
 350   OfferToRenderer(input_event, latency_info, is_keyboard_shortcut);
 351
 352   // Touch events should always indicate in the event whether they are
 353   // cancelable (respect ACK disposition) or not.
 354   bool ignores_ack = WebInputEventTraits::IgnoresAckDisposition(input_event);
 355   if (WebInputEvent::isTouchEventType(input_event.type)) {
 356     DCHECK(!ignores_ack ==
 357            static_cast<const blink::WebTouchEvent&>(input_event).cancelable);
 358   }
 359
 360   // If we don't care about the ack disposition, send the ack immediately.
 361   if (ignores_ack) {
 362     ProcessInputEventAck(input_event.type,
 363                          INPUT_EVENT_ACK_STATE_IGNORED,
 364                          latency_info,
 365                          IGNORING_DISPOSITION);
 366   }
 367 }
 368
 369 bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
 370                                     const ui::LatencyInfo& latency_info) {
 371   bool consumed = false;
 372
 373   InputEventAckState filter_ack =
 374       client_->FilterInputEvent(input_event, latency_info);
 375   switch (filter_ack) {
 376     case INPUT_EVENT_ACK_STATE_CONSUMED:
 377     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS:
 378       // Send the ACK and early exit.
 379       next_mouse_move_.reset();
 380       ProcessInputEventAck(input_event.type, filter_ack, latency_info, CLIENT);
 381       // WARNING: |this| may be deleted at this point.
 382       consumed = true;
 383       break;
 384     case INPUT_EVENT_ACK_STATE_UNKNOWN:
 385       // Simply drop the event.
 386       consumed = true;
 387       break;
 388     default:
 389       break;
 390   }
 391
 392   return consumed;
 393 }
 394
 395 bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event,
 396                                       const ui::LatencyInfo& latency_info,
 397                                       bool is_keyboard_shortcut) {
 398   if (Send(new InputMsg_HandleInputEvent(
 399           routing_id(), &input_event, latency_info, is_keyboard_shortcut))) {
 400     // Ack messages for ignored ack event types should never be sent by the
 401     // renderer. Consequently, such event types should not affect event time
 402     // or in-flight event count metrics.
 403     if (!WebInputEventTraits::IgnoresAckDisposition(input_event)) {
 404       input_event_start_time_ = TimeTicks::Now();
 405       client_->IncrementInFlightEventCount();
 406     }
 407     return true;
 408   }
 409   return false;
 410 }
 411
 412 void InputRouterImpl::SendSyntheticWheelEventForPinch(
 413     const GestureEventWithLatencyInfo& pinch_event) {
 414   // We match typical trackpad behavior on Windows by sending fake wheel events
 415   // with the ctrl modifier set when we see trackpad pinch gestures.  Ideally
 416   // we'd someday get a standard 'pinch' event and send that instead.
 417
 418   WebMouseWheelEvent wheelEvent;
 419   wheelEvent.type = WebInputEvent::MouseWheel;
 420   wheelEvent.timeStampSeconds = pinch_event.event.timeStampSeconds;
 421   wheelEvent.windowX = wheelEvent.x = pinch_event.event.x;
 422   wheelEvent.windowY = wheelEvent.y = pinch_event.event.y;
 423   wheelEvent.globalX = pinch_event.event.globalX;
 424   wheelEvent.globalY = pinch_event.event.globalY;
 425   wheelEvent.modifiers =
 426       pinch_event.event.modifiers | WebInputEvent::ControlKey;
 427   wheelEvent.deltaX = 0;
 428   // The function to convert scales to deltaY values is designed to be
 429   // compatible with websites existing use of wheel events, and with existing
 430   // Windows trackpad behavior.  In particular, we want:
 431   //  - deltas should accumulate via addition: f(s1*s2)==f(s1)+f(s2)
 432   //  - deltas should invert via negation: f(1/s) == -f(s)
 433   //  - zoom in should be positive: f(s) > 0 iff s > 1
 434   //  - magnitude roughly matches wheels: f(2) > 25 && f(2) < 100
 435   //  - a formula that's relatively easy to use from JavaScript
 436   // Note that 'wheel' event deltaY values have their sign inverted.  So to
 437   // convert a wheel deltaY back to a scale use Math.exp(-deltaY/100).
 438   DCHECK_GT(pinch_event.event.data.pinchUpdate.scale, 0);
 439   wheelEvent.deltaY = 100.0f * log(pinch_event.event.data.pinchUpdate.scale);
 440   wheelEvent.hasPreciseScrollingDeltas = true;
 441   wheelEvent.wheelTicksX = 0;
 442   wheelEvent.wheelTicksY =
 443       pinch_event.event.data.pinchUpdate.scale > 1 ? 1 : -1;
 444
 445   SendWheelEvent(QueuedWheelEvent(
 446       MouseWheelEventWithLatencyInfo(wheelEvent, pinch_event.latency), true));
 447 }
 448
 449 void InputRouterImpl::OnInputEventAck(
 450     const InputHostMsg_HandleInputEvent_ACK_Params& ack) {
 451   client_->DecrementInFlightEventCount();
 452
 453   // Log the time delta for processing an input event.
 454   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
 455   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
 456
 457   if (ack.overscroll) {
 458     DCHECK(ack.type == WebInputEvent::MouseWheel ||
 459            ack.type == WebInputEvent::GestureScrollUpdate);
 460     OnDidOverscroll(*ack.overscroll);
 461   }
 462
 463   ProcessInputEventAck(ack.type, ack.state, ack.latency, RENDERER);
 464   // WARNING: |this| may be deleted at this point.
 465
 466   // This is used only for testing, and the other end does not use the
 467   // source object.  On linux, specifying
 468   // Source<RenderWidgetHost> results in a very strange
 469   // runtime error in the epilogue of the enclosing
 470   // (ProcessInputEventAck) method, but not on other platforms; using
 471   // 'void' instead is just as safe (since NotificationSource
 472   // is not actually typesafe) and avoids this error.
 473   int type = static_cast<int>(ack.type);
 474   NotificationService::current()->Notify(
 475       NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
 476       Source<void>(this),
 477       Details<int>(&type));
 478 }
 479
 480 void InputRouterImpl::OnDidOverscroll(const DidOverscrollParams& params) {
 481   client_->DidOverscroll(params);
 482 }
 483
 484 void InputRouterImpl::OnMsgMoveCaretAck() {
 485   move_caret_pending_ = false;
 486   if (next_move_caret_)
 487     SendMoveCaret(next_move_caret_.Pass());
 488 }
 489
 490 void InputRouterImpl::OnSelectRangeAck() {
 491   select_range_pending_ = false;
 492   if (next_selection_range_)
 493     SendSelectRange(next_selection_range_.Pass());
 494 }
 495
 496 void InputRouterImpl::OnHasTouchEventHandlers(bool has_handlers) {
 497   TRACE_EVENT1("input", "InputRouterImpl::OnHasTouchEventHandlers",
 498                "has_handlers", has_handlers);
 499
 500   // Lack of a touch handler indicates that the page either has no touch-action
 501   // modifiers or that all its touch-action modifiers are auto. Resetting the
 502   // touch-action here allows forwarding of subsequent gestures even if the
 503   // underlying touches never reach the router.
 504   // TODO(jdduke): Reset touch-action only at the end of a touch sequence to
 505   // prevent potentially strange mid-sequence behavior, crbug.com/375940.
 506   if (!has_handlers)
 507     touch_action_filter_.ResetTouchAction();
 508
 509   touch_event_queue_.OnHasTouchEventHandlers(has_handlers);
 510   client_->OnHasTouchEventHandlers(has_handlers);
 511 }
 512
 513 void InputRouterImpl::OnSetTouchAction(TouchAction touch_action) {
 514   // Synthetic touchstart events should get filtered out in RenderWidget.
 515   DCHECK(touch_event_queue_.IsPendingAckTouchStart());
 516   TRACE_EVENT1("input", "InputRouterImpl::OnSetTouchAction",
 517                "action", touch_action);
 518
 519   touch_action_filter_.OnSetTouchAction(touch_action);
 520
 521   // TOUCH_ACTION_NONE should disable the touch ack timeout.
 522   UpdateTouchAckTimeoutEnabled();
 523 }
 524
 525 void InputRouterImpl::ProcessInputEventAck(
 526     WebInputEvent::Type event_type,
 527     InputEventAckState ack_result,
 528     const ui::LatencyInfo& latency_info,
 529     AckSource ack_source) {
 530   TRACE_EVENT2("input", "InputRouterImpl::ProcessInputEventAck",
 531                "type", WebInputEventTraits::GetName(event_type),
 532                "ack", GetEventAckName(ack_result));
 533
 534   // Note: The keyboard ack must be treated carefully, as it may result in
 535   // synchronous destruction of |this|. Handling immediately guards against
 536   // future references to |this|, as with |auto_reset_current_ack_source| below.
 537   if (WebInputEvent::isKeyboardEventType(event_type)) {
 538     ProcessKeyboardAck(event_type, ack_result);
 539     // WARNING: |this| may be deleted at this point.
 540     return;
 541   }
 542
 543   base::AutoReset<AckSource> auto_reset_current_ack_source(
 544       &current_ack_source_, ack_source);
 545
 546   if (WebInputEvent::isMouseEventType(event_type)) {
 547     ProcessMouseAck(event_type, ack_result);
 548   } else if (event_type == WebInputEvent::MouseWheel) {
 549     ProcessWheelAck(ack_result, latency_info);
 550   } else if (WebInputEvent::isTouchEventType(event_type)) {
 551     ProcessTouchAck(ack_result, latency_info);
 552   } else if (WebInputEvent::isGestureEventType(event_type)) {
 553     ProcessGestureAck(event_type, ack_result, latency_info);
 554   } else if (event_type != WebInputEvent::Undefined) {
 555     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
 556   }
 557
 558   SignalFlushedIfNecessary();
 559 }
 560
 561 void InputRouterImpl::ProcessKeyboardAck(blink::WebInputEvent::Type type,
 562                                          InputEventAckState ack_result) {
 563   if (key_queue_.empty()) {
 564     ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK);
 565   } else if (key_queue_.front().type != type) {
 566     // Something must be wrong. Clear the |key_queue_| and char event
 567     // suppression so that we can resume from the error.
 568     key_queue_.clear();
 569     ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_EVENT_TYPE);
 570   } else {
 571     NativeWebKeyboardEvent front_item = key_queue_.front();
 572     key_queue_.pop_front();
 573
 574     ack_handler_->OnKeyboardEventAck(front_item, ack_result);
 575     // WARNING: This InputRouterImpl can be deallocated at this point
 576     // (i.e.  in the case of Ctrl+W, where the call to
 577     // HandleKeyboardEvent destroys this InputRouterImpl).
 578     // TODO(jdduke): crbug.com/274029 - Make ack-triggered shutdown async.
 579   }
 580 }
 581
 582 void InputRouterImpl::ProcessMouseAck(blink::WebInputEvent::Type type,
 583                                       InputEventAckState ack_result) {
 584   if (type != WebInputEvent::MouseMove)
 585     return;
 586
 587   DCHECK(mouse_move_pending_);
 588   mouse_move_pending_ = false;
 589
 590   if (next_mouse_move_) {
 591     DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
 592     scoped_ptr<MouseEventWithLatencyInfo> next_mouse_move
 593         = next_mouse_move_.Pass();
 594     SendMouseEvent(*next_mouse_move);
 595   }
 596 }
 597
 598 void InputRouterImpl::ProcessWheelAck(InputEventAckState ack_result,
 599                                       const ui::LatencyInfo& latency) {
 600   // TODO(miletus): Add renderer side latency to each uncoalesced mouse
 601   // wheel event and add terminal component to each of them.
 602   current_wheel_event_.event.latency.AddNewLatencyFrom(latency);
 603
 604   if (current_wheel_event_.synthesized_from_pinch) {
 605     // Ack the GesturePinchUpdate event that generated this wheel event.
 606     ProcessInputEventAck(WebInputEvent::GesturePinchUpdate,
 607                          ack_result,
 608                          current_wheel_event_.event.latency,
 609                          current_ack_source_);
 610   } else {
 611     // Process the unhandled wheel event here before calling SendWheelEvent()
 612     // since it will mutate current_wheel_event_.
 613     ack_handler_->OnWheelEventAck(current_wheel_event_.event, ack_result);
 614   }
 615
 616   // Mark the wheel event complete only after the ACKs have been handled above.
 617   // For example, ACKing the GesturePinchUpdate could cause another
 618   // GesturePinchUpdate to be sent, which should queue a wheel event rather than
 619   // send it immediately.
 620   mouse_wheel_pending_ = false;
 621
 622   // Send the next (coalesced or synthetic) mouse wheel event.
 623   if (!coalesced_mouse_wheel_events_.empty()) {
 624     QueuedWheelEvent next_wheel_event = coalesced_mouse_wheel_events_.front();
 625     coalesced_mouse_wheel_events_.pop_front();
 626     SendWheelEvent(next_wheel_event);
 627   }
 628 }
 629
 630 void InputRouterImpl::ProcessGestureAck(WebInputEvent::Type type,
 631                                         InputEventAckState ack_result,
 632                                         const ui::LatencyInfo& latency) {
 633   if (!gesture_event_queue_.ExpectingGestureAck())
 634     return;
 635
 636   // |gesture_event_queue_| will forward to OnGestureEventAck when appropriate.
 637   gesture_event_queue_.ProcessGestureAck(ack_result, type, latency);
 638 }
 639
 640 void InputRouterImpl::ProcessTouchAck(
 641     InputEventAckState ack_result,
 642     const ui::LatencyInfo& latency) {
 643   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
 644   touch_event_queue_.ProcessTouchAck(ack_result, latency);
 645 }
 646
 647 void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {
 648   // Mobile sites tend to be well-behaved with respect to touch handling, so
 649   // they have less need for the touch timeout fallback.
 650   const bool fixed_page_scale = (current_view_flags_ & FIXED_PAGE_SCALE) != 0;
 651   const bool mobile_viewport = (current_view_flags_ & MOBILE_VIEWPORT) != 0;
 652
 653   // TOUCH_ACTION_NONE will prevent scrolling, in which case the timeout serves
 654   // little purpose. It's also a strong signal that touch handling is critical
 655   // to page functionality, so the timeout could do more harm than good.
 656   const bool touch_action_none =
 657       touch_action_filter_.allowed_touch_action() == TOUCH_ACTION_NONE;
 658
 659   const bool touch_ack_timeout_enabled = !fixed_page_scale &&
 660                                          !mobile_viewport &&
 661                                          !touch_action_none;
 662   touch_event_queue_.SetAckTimeoutEnabled(touch_ack_timeout_enabled);
 663 }
 664
 665 void InputRouterImpl::SignalFlushedIfNecessary() {
 666   if (!flush_requested_)
 667     return;
 668
 669   if (HasPendingEvents())
 670     return;
 671
 672   flush_requested_ = false;
 673   client_->DidFlush();
 674 }
 675
 676 bool InputRouterImpl::HasPendingEvents() const {
 677   return !touch_event_queue_.empty() ||
 678          !gesture_event_queue_.empty() ||
 679          !key_queue_.empty() ||
 680          mouse_move_pending_ ||
 681          mouse_wheel_pending_ ||
 682          select_range_pending_ ||
 683          move_caret_pending_;
 684 }
 685
 686 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent()
 687     : synthesized_from_pinch(false) {
 688 }
 689
 690 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent(
 691     const MouseWheelEventWithLatencyInfo& event,
 692     bool synthesized_from_pinch)
 693     : event(event), synthesized_from_pinch(synthesized_from_pinch) {
 694 }
 695
 696 InputRouterImpl::QueuedWheelEvent::~QueuedWheelEvent() {
 697 }
 698
 699 }  // namespace content