Unify Android Webview and Chrome's fling

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 "android_webview/browser/child_frame.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 396 matching lines @@
 }
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   shared_renderer_state_.ReleaseHardwareDrawIfNeededOnUI();
   attached_to_window_ = false;
   DCHECK(!hardware_enabled_);
   UpdateCompositorIsActive();
 }
 
+void BrowserViewRenderer::OnComputeScroll(base::TimeTicks animation_time) {
+  if (pending_fling_animation_.is_null())
+    return;
+  FlushPendingScrollAnimation(animation_time);
+}
+
 void BrowserViewRenderer::ReleaseHardware() {
   DCHECK(hardware_enabled_);
   ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
   ReturnResourceFromParent();
   DCHECK(shared_renderer_state_.ReturnedResourcesEmptyOnUI());
 
   if (compositor_) {
     compositor_->SetMemoryPolicy(0u);
   }
 
@@ skipping 116 matching lines @@
   DCHECK_LE(scroll_offset.x(), max_offset.x());
   DCHECK_LE(scroll_offset.y(), max_offset.y());
 
   client_->ScrollContainerViewTo(scroll_offset);
 }
 
 gfx::Vector2dF BrowserViewRenderer::GetTotalRootLayerScrollOffset() {
   return scroll_offset_dip_;
 }
 
-bool BrowserViewRenderer::IsExternalFlingActive() const {
-  return client_->IsFlingActive();
+bool BrowserViewRenderer::IsExternalScrollActive() const {
+  return client_->IsSmoothScrollingActive();
 }
 
 void BrowserViewRenderer::UpdateRootLayerState(
     const gfx::Vector2dF& total_scroll_offset_dip,
     const gfx::Vector2dF& max_scroll_offset_dip,
     const gfx::SizeF& scrollable_size_dip,
     float page_scale_factor,
     float min_page_scale_factor,
     float max_page_scale_factor) {
   TRACE_EVENT_INSTANT1(
@@ skipping 33 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::SetNeedsAnimateScroll(
+    const AnimationCallback& scroll_animation) {
+  pending_fling_animation_ = scroll_animation;
+  client_->PostInvalidate();

[boliu, 2015/05/29 19:42:47]

Conceptually this feels wrong. What does "SetNeedAnimate" have to do with
invalidates? You are waiting for OnComputeScroll, and PostInvalidate is for
OnDraws.

Have we considered moving driving animations to the animate step? Is that how
chrome works, etc? How does this work before this CL?

And more practically, does this need to be integrated into
PostInvalidateWithFallback? ie pending_fling_animation_.is_null() will be one
more state that controls whether fallback ticks should be scheduled or
cancelled.

[hush (inactive), 2015/06/05 21:47:21]

We've discussed this in person.
The fling animation is driven by "computeScroll" call which is an Android view
api. And we have to hook fling with it because there are applications (Inbox for
example) that rely on that fact to overide computeScroll to nothing to achieve
their own custom fling.
computeScroll is called within View#updateDisplayListIfDirty, which is during
the draw step, instead of animation step, from the choreorgrapher's point of
view.

I will update description about how this works before and after this CL. Sorry
for the short description there..
I think you mean when pending_fling_animation_ is not null, there is no point in
rescheduling fallback ticks because there is definitely a PostInvalidate in
flight. I will do it.

+}
+
 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);
+

[boliu, 2015/05/29 19:42:47]

nit: blank lines

[hush (inactive), 2015/06/05 21:47:21]

Done.

+  gfx::Vector2dF fling_velocity_pixels =
+      gfx::ScaleVector2d(current_fling_velocity, physical_pixel_scale);
+
+  client_->DidOverscroll(rounded_overscroll_delta, fling_velocity_pixels);
 }
 
 void BrowserViewRenderer::PostInvalidate() {
   TRACE_EVENT_INSTANT0("android_webview", "BrowserViewRenderer::PostInvalidate",
                        TRACE_EVENT_SCOPE_THREAD);
   PostInvalidateWithFallback();
 }
 
 void BrowserViewRenderer::PostInvalidateWithFallback() {
   // Always call view invalidate. We rely the Android framework to ignore the
@@ skipping 56 matching lines @@
 
 void BrowserViewRenderer::ForceFakeCompositeSW() {
   DCHECK(compositor_);
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(0);
   SkCanvas canvas(bitmap);
   CompositeSW(&canvas);
 }
 
+void BrowserViewRenderer::FlushPendingScrollAnimation(

[boliu, 2015/05/29 19:42:47]

There is only one call site. Just inline this?

[hush (inactive), 2015/06/05 21:47:21]

Done.

+    base::TimeTicks animation_time) {
+  TRACE_EVENT0("android_webview",
+               "BrowserViewRenderer::FlushPendingScrollAnimation");
+  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_);
   CancelFallbackTick();
   ReturnResourceFromParent();
   return compositor_->DemandDrawSw(canvas);
 }
 
 void BrowserViewRenderer::UpdateCompositorIsActive() {
   if (compositor_)
     compositor_->SetIsActive(!is_paused_ &&
@@ skipping 19 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