sync compositor: Signal async frame on IO thread

android_webview/browser/render_thread_manager.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/render_thread_manager.h"
 
 #include <utility>
 
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/compositor_frame_producer.h"
@@ skipping 175 matching lines @@
         frame_future) {
   base::AutoLock lock(lock_);
   DCHECK(!child_frame_.get());
   child_frame_ = std::move(frame);
   frame_future_ = std::move(frame_future);
 }
 
 std::unique_ptr<ChildFrame> RenderThreadManager::GetSynchronousCompositorFrame(
     scoped_refptr<content::SynchronousCompositor::FrameFuture> frame_future,
     std::unique_ptr<ChildFrame> child_frame) {
+  if (!frame_future)
+    return nullptr;
   DCHECK(!child_frame->frame.get());
   std::unique_ptr<content::SynchronousCompositor::Frame> frame =
       frame_future->getFrame();
   std::unique_ptr<cc::CompositorFrame> compositor_frame =
       std::move(frame->frame);
   return base::MakeUnique<ChildFrame>(
       frame->compositor_frame_sink_id, std::move(compositor_frame),
       child_frame->compositor_id,
       child_frame->viewport_rect_for_tile_priority_empty,
       child_frame->transform_for_tile_priority,
       child_frame->offscreen_pre_raster, child_frame->is_layer);
 }
 
 std::unique_ptr<ChildFrame> RenderThreadManager::PassFrameOnRT() {
   base::AutoLock lock(lock_);
   hardware_renderer_has_frame_ =
       hardware_renderer_has_frame_ || child_frame_.get();
-  if (async_on_draw_hardware_ && child_frame_.get()) {
-    return GetSynchronousCompositorFrame(std::move(frame_future_),
-                                         std::move(child_frame_));
-  }
   return std::move(child_frame_);
 }
 
+scoped_refptr<content::SynchronousCompositor::FrameFuture>
+RenderThreadManager::PassFrameFutureOnRT() {
+  base::AutoLock lock(lock_);
+  return std::move(frame_future_);
+}
+
 std::unique_ptr<ChildFrame> RenderThreadManager::PassUncommittedFrameOnUI() {
   base::AutoLock lock(lock_);
   if (async_on_draw_hardware_ && child_frame_.get()) {
     return GetSynchronousCompositorFrame(std::move(frame_future_),
                                          std::move(child_frame_));
   }
   return std::move(child_frame_);
 }
 
 void RenderThreadManager::PostExternalDrawConstraintsToChildCompositorOnRT(
@@ skipping 193 matching lines @@
     : render_thread_manager_(render_thread_manager) {
   DCHECK(!render_thread_manager_->IsInsideHardwareRelease());
   render_thread_manager_->SetInsideHardwareRelease(true);
 }
 
 RenderThreadManager::InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
   render_thread_manager_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview