Bundle main thread overscroll data with event ack messages

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/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 473 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_granted_(false),
       display_mode_(blink::WebDisplayModeUndefined),
       has_focus_(false),
       handling_input_event_(false),
+      handling_event_overscroll_(nullptr),
       handling_ime_event_(false),
       handling_event_type_(WebInputEvent::Undefined),
       ignore_ack_for_mouse_move_from_debugger_(false),
       closing_(false),
       host_closing_(false),
       is_swapped_out_(swapped_out),
       for_oopif_(false),
       input_method_is_active_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
@@ skipping 556 matching lines @@
 void RenderWidget::OnSwapBuffersComplete() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
 
   // Notify subclasses that composited rendering was flushed to the screen.
   DidFlushPaint();
 }
 
 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info,
                                       bool is_keyboard_shortcut) {
-  base::AutoReset<bool> handling_input_event_resetter(
-      &handling_input_event_, true);
   if (!input_event)
     return;
+  base::AutoReset<bool> handling_input_event_resetter(&handling_input_event_,
+                                                      true);
   base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
       &handling_event_type_, input_event->type);
+
+  // Calls into |didOverscroll()| while handling this event will populate
+  // |event_overscroll|, which in turn will be bundled with the event ack.
+  scoped_ptr<DidOverscrollParams> event_overscroll;
+  base::AutoReset<scoped_ptr<DidOverscrollParams>*>
+      handling_event_overscroll_resetter(&handling_event_overscroll_,
+                                         &event_overscroll);
+
 #if defined(OS_ANDROID)
   // On Android, when a key is pressed or sent from the Keyboard using IME,
   // |AdapterInputConnection| generates input key events to make sure all JS
   // listeners that monitor KeyUp and KeyDown events receive the proper key
   // code. Since this input key event comes from IME, we need to set the
   // IME event guard here to make sure it does not interfere with other IME
   // events.
   scoped_ptr<ImeEventGuard> ime_event_guard_maybe;
   if (WebInputEvent::isKeyboardEventType(input_event->type)) {
     const WebKeyboardEvent& key_event =
@@ skipping 133 matching lines @@
 
   TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
 
   // 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_mouse_move_from_debugger_ &&
       input_event->type == WebInputEvent::MouseMove;
   if (WebInputEventTraits::WillReceiveAckFromRenderer(*input_event) &&
       !no_ack) {
     InputEventAck ack(input_event->type, ack_result, swap_latency_info,
+                      event_overscroll.Pass(),
                       WebInputEventTraits::GetUniqueTouchEventId(*input_event));
     scoped_ptr<IPC::Message> response(
         new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
     if (rate_limiting_wanted && 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_) {
         TRACE_EVENT_ASYNC_END0("input", "RenderWidget::ThrottledInputEventAck",
                                pending_input_event_ack_.get());
         // 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();
       TRACE_EVENT_ASYNC_BEGIN0("input", "RenderWidget::ThrottledInputEventAck",
                                pending_input_event_ack_.get());
       if (compositor_)
         compositor_->NotifyInputThrottledUntilCommit();
     } else {
       Send(response.release());
     }
+  } else {
+    DCHECK(!event_overscroll) << "Unexpected overscroll for un-acked event";
   }
   if (!no_ack && RenderThreadImpl::current()) {
     RenderThreadImpl::current()
         ->GetRendererScheduler()
         ->DidHandleInputEventOnMainThread(*input_event);
   }
   if (input_event->type == WebInputEvent::MouseMove)
     ignore_ack_for_mouse_move_from_debugger_ = false;
 
 #if defined(OS_ANDROID)
@@ skipping 950 matching lines @@
   }
 #endif
 }
 
 void RenderWidget::didOverscroll(
     const blink::WebFloatSize& unusedDelta,
     const blink::WebFloatSize& accumulatedRootOverScroll,
     const blink::WebFloatPoint& position,
     const blink::WebFloatSize& velocity) {
   DidOverscrollParams params;
-  // TODO(jdduke): Consider bundling the overscroll with the input event ack to
-  // save an IPC.
   params.accumulated_overscroll = gfx::Vector2dF(
       accumulatedRootOverScroll.width, accumulatedRootOverScroll.height);
   params.latest_overscroll_delta =
       gfx::Vector2dF(unusedDelta.width, unusedDelta.height);
   // TODO(sataya.m): don't negate velocity once http://crbug.com/499743 is
   // fixed.
   params.current_fling_velocity =
       gfx::Vector2dF(-velocity.width, -velocity.height);
   params.causal_event_viewport_point = gfx::PointF(position.x, position.y);
+
+  // If we're currently handling an event, stash the overscroll data such that
+  // it can be bundled in the event ack.
+  if (handling_event_overscroll_) {
+    handling_event_overscroll_->reset(new DidOverscrollParams(params));
+    return;
+  }
+
   Send(new InputHostMsg_DidOverscroll(routing_id_, params));
 }
 
 void RenderWidget::StartCompositor() {
   // For widgets that are never visible, we don't need the compositor to run
   // at all.
   if (never_visible_)
     return;
   // In tests without a RenderThreadImpl, don't set ready as this kicks
   // off creating output surfaces that the test can't create.
@@ skipping 210 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content