Setting Accurate ScrollResult from Blink for Elastic Scroll.

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 1190 matching lines @@
         ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
         break;
       }
     }
   }
 
   // Send mouse wheel events and their disposition to the compositor thread, so
   // that they can be used to produce the elastic overscroll effect on Mac.
   if (input_event->type == WebInputEvent::MouseWheel) {
     ObserveWheelEventAndResult(
-        static_cast<const WebMouseWheelEvent&>(*input_event), processed);
+        static_cast<const WebMouseWheelEvent&>(*input_event),
+        event_overscroll ? event_overscroll->latest_overscroll_delta
+                         : gfx::Vector2dF(),
+        processed);
   }
 
   bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
 
   // If we don't have a fast and accurate Now(), we assume the input handlers
   // are heavy and rate limit them.
   bool rate_limiting_wanted =
       input_event->type == WebInputEvent::MouseMove ||
       input_event->type == WebInputEvent::MouseWheel;
   if (rate_limiting_wanted && !start_time.is_null()) {
@@ skipping 935 matching lines @@
   // We assume that the absence of synchronous_compositor_factory
   // means we are in Chrome. In chrome, we want to clip, i.e.
   // *not* to record the full layer.
   if (!synchronous_compositor_factory)
     return false;
 
   return synchronous_compositor_factory->RecordFullLayer();
 }
 #endif
 
+bool RenderWidget::IsElasticOverscrollEnabled() const {
+  return compositor_deps_->IsElasticOverscrollEnabled();
+}
+
 bool RenderWidget::CanComposeInline() {
   return true;
 }
 
 WebScreenInfo RenderWidget::screenInfo() {
   return screen_info_;
 }
 
 float RenderWidget::deviceScaleFactor() {
   return device_scale_factor_;
@@ skipping 124 matching lines @@
   return false;
 }
 
 bool RenderWidget::WillHandleGestureEvent(
     const blink::WebGestureEvent& event) {
   return false;
 }
 
 void RenderWidget::ObserveWheelEventAndResult(
     const blink::WebMouseWheelEvent& wheel_event,
+    const gfx::Vector2dF& wheel_unused_delta,
     bool event_processed) {
   if (!compositor_deps_->IsElasticOverscrollEnabled())
     return;
 
-  // Blink does not accurately compute scroll bubbling or overscroll. For now,
-  // assume that an unprocessed event was entirely an overscroll, and that a
-  // processed event was entirely scroll.
-  // TODO(ccameron): Retrieve an accurate scroll result from Blink.
-  // http://crbug.com/442859
   cc::InputHandlerScrollResult scroll_result;
-  if (event_processed) {
-    scroll_result.did_scroll = true;
-  } else {
-    scroll_result.did_overscroll_root = true;
-    scroll_result.unused_scroll_delta =
-        gfx::Vector2dF(-wheel_event.deltaX, -wheel_event.deltaY);
-  }
+  scroll_result.did_scroll = event_processed;
+  scroll_result.did_overscroll_root = !wheel_unused_delta.IsZero();
+  scroll_result.unused_scroll_delta = wheel_unused_delta;
 
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   InputHandlerManager* input_handler_manager =
       render_thread ? render_thread->input_handler_manager() : NULL;
   if (input_handler_manager) {
     input_handler_manager->ObserveWheelEventAndResultOnMainThread(
         routing_id_, wheel_event, scroll_result);
   }
 }
 
@@ skipping 135 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