[DevTools] Send ack early when paused in mouse move to keep events coming.

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
@@ skipping 355 matching lines @@
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
       never_visible_(never_visible),
       is_fullscreen_(false),
       has_focus_(false),
       handling_input_event_(false),
       handling_ime_event_(false),
-      handling_touchstart_event_(false),
+      handling_event_type_(WebInputEvent::Undefined),
+      ignore_ack_for_current_mouse_move_(false),
       closing_(false),
       is_swapped_out_(swapped_out),
       input_method_is_active_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       can_compose_inline_(true),
       popup_type_(popup_type),
       pending_window_rect_count_(0),
       suppress_next_char_events_(false),
       is_accelerated_compositing_active_(false),
@@ skipping 522 matching lines @@
 }
 
 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info,
                                       bool is_keyboard_shortcut) {
   handling_input_event_ = true;
   if (!input_event) {
     handling_input_event_ = false;
     return;
   }
+  handling_event_type_ = input_event->type;
 
   base::TimeTicks start_time;
   if (base::TimeTicks::IsHighResNowFastAndReliable())
     start_time = base::TimeTicks::HighResNow();
 
   const char* const event_name =
       WebInputEventTraits::GetName(input_event->type);
   TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
                "event", event_name);
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
@@ skipping 65 matching lines @@
 #endif
   }
 
   if (WebInputEvent::isGestureEventType(input_event->type)) {
     const WebGestureEvent& gesture_event =
         *static_cast<const WebGestureEvent*>(input_event);
     context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
     prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
   }
 
-  if (input_event->type == WebInputEvent::TouchStart)
-      handling_touchstart_event_ = true;
-
   bool processed = prevent_default;
   if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
     suppress_next_char_events_ = false;
     if (!processed && webwidget_)
       processed = webwidget_->handleInputEvent(*input_event);
   }
 
-  handling_touchstart_event_ = false;
-
   // If this RawKeyDown event corresponds to a browser keyboard shortcut and
   // it's not processed by webkit, then we need to suppress the upcoming Char
   // events.
   if (!processed && is_keyboard_shortcut)
     suppress_next_char_events_ = true;
 
   InputEventAckState ack_result = processed ?
       INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
   if (!processed &&  input_event->type == WebInputEvent::TouchStart) {
     const WebTouchEvent& touch_event =
@@ skipping 28 matching lines @@
   if (base::TimeTicks::IsHighResNowFastAndReliable()) {
       base::TimeTicks end_time = base::TimeTicks::HighResNow();
       total_input_handling_time_this_frame_ += (end_time - start_time);
       rate_limiting_wanted =
           total_input_handling_time_this_frame_.InMicroseconds() >
           kInputHandlingTimeThrottlingThresholdMicroseconds;
   }
 
   TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
 
-  if (!WebInputEventTraits::IgnoresAckDisposition(*input_event)) {
+  // Note that we can't use handling_event_type_ here since it will be overriden
+  // by reentrant calls for events after the paused one.
+  bool no_ack = ignore_ack_for_current_mouse_move_ &&
+      input_event->type == WebInputEvent::MouseMove;
+  if (!WebInputEventTraits::IgnoresAckDisposition(*input_event) && !no_ack) {
     scoped_ptr<IPC::Message> response(
         new InputHostMsg_HandleInputEvent_ACK(routing_id_,
                                               input_event->type,
                                               ack_result,
                                               swap_latency_info));
     if (rate_limiting_wanted && event_type_can_be_rate_limited &&
         frame_pending && !is_hidden_) {
       // We want to rate limit the input events in this case, so we'll wait for
       // painting to finish before ACKing this message.
       TRACE_EVENT_INSTANT0("renderer",
         "RenderWidget::OnHandleInputEvent ack throttled",
         TRACE_EVENT_SCOPE_THREAD);
       if (pending_input_event_ack_) {
         // As two different kinds of events could cause us to postpone an ack
         // we send it now, if we have one pending. The Browser should never
         // send us the same kind of event we are delaying the ack for.
         Send(pending_input_event_ack_.release());
       }
       pending_input_event_ack_ = response.Pass();
       if (compositor_)
         compositor_->NotifyInputThrottledUntilCommit();
     } else {
       Send(response.release());
     }
   }
+  ignore_ack_for_current_mouse_move_ = false;
 
 #if defined(OS_ANDROID)
   // Allow the IME to be shown when the focus changes as a consequence
   // of a processed touch end event.
   if (input_event->type == WebInputEvent::TouchEnd && processed)
     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
 #elif defined(USE_AURA)
   // Show the virtual keyboard if enabled and a user gesture triggers a focus
   // change.
   if (processed && (input_event->type == WebInputEvent::TouchEnd ||
       input_event->type == WebInputEvent::MouseUp))
     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
 #endif
 
+  handling_event_type_ = WebInputEvent::Undefined;
   handling_input_event_ = false;
 
   if (!prevent_default) {
     if (WebInputEvent::isKeyboardEventType(input_event->type))
       DidHandleKeyEvent();
     if (WebInputEvent::isMouseEventType(input_event->type))
       DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
     if (WebInputEvent::isTouchEventType(input_event->type))
       DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
   }
@@ skipping 420 matching lines @@
 #endif
 
 bool RenderWidget::ShouldHandleImeEvent() {
 #if defined(OS_ANDROID)
   return !!webwidget_ && outstanding_ime_acks_ == 0;
 #else
   return !!webwidget_;
 #endif
 }
 
+bool RenderWidget::SendAckForCurrentMouseMove() {
+  if (handling_event_type_ == WebInputEvent::MouseMove) {
+    Send(new InputHostMsg_HandleInputEvent_ACK(routing_id_,
+                                               handling_event_type_,
+                                               INPUT_EVENT_ACK_STATE_CONSUMED,
+                                               ui::LatencyInfo()));
+    return true;
+  }
+  return false;
+}
+
+void RenderWidget::IgnoreAckForCurrentMouseMove() {
+  ignore_ack_for_current_mouse_move_ = true;
+}
+
 void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
 
   device_scale_factor_ = device_scale_factor;
 
   if (!is_accelerated_compositing_active_) {
     didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
   } else {
     scheduleComposite();
@@ skipping 431 matching lines @@
 
 void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
   Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
 }
 
 void RenderWidget::setTouchAction(
     blink::WebTouchAction web_touch_action) {
 
   // Ignore setTouchAction calls that result from synthetic touch events (eg.
   // when blink is emulating touch with mouse).
-  if (!handling_touchstart_event_)
+  if (!handling_event_type_ == WebInputEvent::TouchStart)
     return;
 
    // Verify the same values are used by the types so we can cast between them.
    COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_AUTO) ==
                       blink::WebTouchActionAuto,
                   enum_values_must_match_for_touch_action);
    COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_NONE) ==
                       blink::WebTouchActionNone,
                   enum_values_must_match_for_touch_action);
    COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_X) ==
@@ skipping 97 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content