NOT FOR LANDING - [WebView] Allow fling animation via the LayerScrollOffsetDelegate

android_webview/browser/browser_view_renderer.cc

 // Copyright 2014 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 "android_webview/browser/browser_view_renderer.h"
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 404 matching lines @@
   size_.SetSize(width, height);
 }
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   shared_renderer_state_.ReleaseHardwareDrawIfNeededOnUI();
   attached_to_window_ = false;
   DCHECK(!hardware_enabled_);
 }
 
+void BrowserViewRenderer::OnComputeScroll(base::TimeTicks animation_time) {
+  if (pending_fling_animation_.is_null())
+    return;
+  FlushPendingFlingAnimation(animation_time);
+}
+
 void BrowserViewRenderer::ReleaseHardware() {
   DCHECK(hardware_enabled_);
   ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
   ReturnResourceFromParent();
   DCHECK(shared_renderer_state_.ReturnedResourcesEmptyOnUI());
 
   if (compositor_) {
     compositor_->ReleaseHwDraw();
   }
 
@@ skipping 184 matching lines @@
   state->SetDouble("max_scroll_offset_dip.x", max_scroll_offset_dip_.x());
   state->SetDouble("max_scroll_offset_dip.y", max_scroll_offset_dip_.y());
 
   state->SetDouble("scrollable_size_dip.width", scrollable_size_dip.width());
   state->SetDouble("scrollable_size_dip.height", scrollable_size_dip.height());
 
   state->SetDouble("page_scale_factor", page_scale_factor_);
   return state;
 }
 
+void BrowserViewRenderer::SetNeedsAnimateFling(
+    const AnimationCallback& fling_animation) {
+  // TODO(jdduke): Skip invalidate if animation already pending?
+  pending_fling_animation_ = fling_animation;
+  client_->PostInvalidate();
+}
+
 void BrowserViewRenderer::DidOverscroll(gfx::Vector2dF accumulated_overscroll,
                                         gfx::Vector2dF latest_overscroll_delta,
                                         gfx::Vector2dF current_fling_velocity) {
   const float physical_pixel_scale = dip_scale_ * page_scale_factor_;
   if (accumulated_overscroll == latest_overscroll_delta)
     overscroll_rounding_error_ = gfx::Vector2dF();
   gfx::Vector2dF scaled_overscroll_delta =
       gfx::ScaleVector2d(latest_overscroll_delta, physical_pixel_scale);
   gfx::Vector2d rounded_overscroll_delta = gfx::ToRoundedVector2d(
       scaled_overscroll_delta + overscroll_rounding_error_);
   overscroll_rounding_error_ =
       scaled_overscroll_delta - rounded_overscroll_delta;
-  client_->DidOverscroll(rounded_overscroll_delta);
+
+  gfx::Vector2dF fling_velocity_pixels = gfx::ScaleVector2d(
+      current_fling_velocity, physical_pixel_scale);
+
+  const bool first_overscroll_x =
+      accumulated_overscroll.x() &&
+      accumulated_overscroll.x() == latest_overscroll_delta.x();
+  const bool first_overscroll_y =
+      accumulated_overscroll.y() &&
+      accumulated_overscroll.y() == latest_overscroll_delta.y();
+
+  client_->DidOverscroll(rounded_overscroll_delta,
+                         fling_velocity_pixels,
+                         first_overscroll_x,
+                         first_overscroll_y);
 }
 
 void BrowserViewRenderer::EnsureContinuousInvalidation(
     bool force_invalidate,
     bool skip_reschedule_tick) {
   if (force_invalidate)
     invalidate_after_composite_ = true;
 
   // This method should be called again when any of these conditions change.
   bool need_invalidate =
@@ skipping 83 matching lines @@
 
 void BrowserViewRenderer::ForceFakeCompositeSW() {
   DCHECK(compositor_);
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(0);
   SkCanvas canvas(bitmap);
   CompositeSW(&canvas);
 }
 
+void BrowserViewRenderer::FlushPendingFlingAnimation(
+    base::TimeTicks animation_time) {
+  TRACE_EVENT0("android_webview",
+               "BrowserViewRenderer::FlushPendingFlingAnimation");
+  DCHECK(!pending_fling_animation_.is_null());
+  AnimationCallback animation = pending_fling_animation_;
+  pending_fling_animation_.Reset();
+  animation.Run(animation_time);
+}
+
 bool BrowserViewRenderer::CompositeSW(SkCanvas* canvas) {
   DCHECK(compositor_);
   ReturnResourceFromParent();
   bool result = compositor_->DemandDrawSw(canvas);
   DidComposite();
   return result;
 }
 
 void BrowserViewRenderer::DidComposite() {
   block_invalidates_ = false;
@@ skipping 29 matching lines @@
   base::StringAppendF(&str,
                       "overscroll_rounding_error_: %s ",
                       overscroll_rounding_error_.ToString().c_str());
   base::StringAppendF(
       &str, "on_new_picture_enable: %d ", on_new_picture_enable_);
   base::StringAppendF(&str, "clear_view: %d ", clear_view_);
   return str;
 }
 
 }  // namespace android_webview