Added FrameFuture class

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"
 #include "android_webview/browser/compositor_id.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
 #include "android_webview/browser/hardware_renderer.h"
 #include "android_webview/browser/render_thread_manager_client.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
+#include "android_webview/common/aw_switches.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "cc/output/compositor_frame.h"
 
 namespace android_webview {
 
 namespace internal {
 
 class RequestInvokeGLTracker {
  public:
   RequestInvokeGLTracker();
   bool ShouldRequestOnNonUiThread(RenderThreadManager* state);
   bool ShouldRequestOnUiThread(RenderThreadManager* state);
@@ skipping 57 matching lines @@
 }
 
 RenderThreadManager::RenderThreadManager(
     RenderThreadManagerClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop)
     : ui_loop_(ui_loop),
       client_(client),
       compositor_frame_producer_(nullptr),
       renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()),
       hardware_renderer_has_frame_(false),
+      async_on_draw_hardware_(base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAsyncOnDrawHardware)),
       inside_hardware_release_(false),
       weak_factory_on_ui_thread_(this) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(client_);
   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
   ResetRequestInvokeGLCallback();
 }
 
 RenderThreadManager::~RenderThreadManager() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
@@ skipping 57 matching lines @@
 void RenderThreadManager::SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) {
   base::AutoLock lock(lock_);
   scroll_offset_ = scroll_offset;
 }
 
 gfx::Vector2d RenderThreadManager::GetScrollOffsetOnRT() {
   base::AutoLock lock(lock_);
   return scroll_offset_;
 }
 
-void RenderThreadManager::SetFrameOnUI(std::unique_ptr<ChildFrame> frame) {
+void RenderThreadManager::SetFrameOnUI(
+    std::unique_ptr<ChildFrame> frame,
+    const scoped_refptr<content::SynchronousCompositor::FrameFuture>&
+        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) {
+  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_);
 }
 
 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(
     const ParentCompositorDrawConstraints& parent_draw_constraints) {
   {
     base::AutoLock lock(lock_);
     parent_draw_constraints_ = parent_draw_constraints;
   }
 
@@ skipping 187 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