sync compositor: Keep draw after ComputeScroll synchronous

content/browser/android/synchronous_compositor_host.cc

 // Copyright 2015 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/browser/android/synchronous_compositor_host.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
@@ skipping 86 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 scoped_refptr<SynchronousCompositor::FrameFuture>
 SynchronousCompositorHost::DemandDrawHwAsync(
     const gfx::Size& viewport_size,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
+  scoped_refptr<FrameFuture> frame_future = new FrameFuture();
+  if (compute_scroll_needs_synchronous_draw_) {
+    compute_scroll_needs_synchronous_draw_ = false;
+    auto frame_ptr = base::MakeUnique<Frame>();
+    *frame_ptr = DemandDrawHw(viewport_size, viewport_rect_for_tile_priority,
+                              transform_for_tile_priority);
+    frame_future->SetFrame(std::move(frame_ptr));
+    return frame_future;
+  }
+
   SyncCompositorDemandDrawHwParams params(viewport_size,
                                           viewport_rect_for_tile_priority,
                                           transform_for_tile_priority);
-  scoped_refptr<FrameFuture> frame_future = new FrameFuture();
   if (SynchronousCompositorBrowserFilter* filter = GetFilter()) {
     if (!registered_with_filter_) {
       filter->RegisterHost(this);
       registered_with_filter_ = true;
     }
     filter->SetFrameFuture(routing_id_, frame_future);
     sender_->Send(new SyncCompositorMsg_DemandDrawHwAsync(routing_id_, params));
   } else {
     frame_future->SetFrame(nullptr);
   }
@@ skipping 235 matching lines @@
 
 void SynchronousCompositorHost::OnComputeScroll(
     base::TimeTicks animation_time) {
   if (!need_animate_scroll_)
     return;
   need_animate_scroll_ = false;
 
   SyncCompositorCommonRendererParams common_renderer_params;
   sender_->Send(
       new SyncCompositorMsg_ComputeScroll(routing_id_, animation_time));
+  compute_scroll_needs_synchronous_draw_ = true;
 }
 
 void SynchronousCompositorHost::DidOverscroll(
     const ui::DidOverscrollParams& over_scroll_params) {
   client_->DidOverscroll(this, over_scroll_params.accumulated_overscroll,
                          over_scroll_params.latest_overscroll_delta,
                          over_scroll_params.current_fling_velocity);
 }
 
 void SynchronousCompositorHost::DidSendBeginFrame(
     ui::WindowAndroid* window_android) {
+  compute_scroll_needs_synchronous_draw_ = false;
   if (SynchronousCompositorBrowserFilter* filter = GetFilter())
     filter->SyncStateAfterVSync(window_android, this);
 }
 
 void SynchronousCompositorHost::CompositorFrameSinkCreated() {
   // New CompositorFrameSink is not aware of state from Browser side. So need to
   // re-send all browser side state here.
   sender_->Send(
       new SyncCompositorMsg_SetMemoryPolicy(routing_id_, bytes_limit_));
 }
@@ skipping 26 matching lines @@
   if (params.page_scale_factor) {
     client_->UpdateRootLayerState(
         this, gfx::ScrollOffsetToVector2dF(params.total_scroll_offset),
         gfx::ScrollOffsetToVector2dF(params.max_scroll_offset),
         params.scrollable_size, params.page_scale_factor,
         params.min_page_scale_factor, params.max_page_scale_factor);
   }
 }
 
 }  // namespace content