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 63 matching lines @@
   base::AutoLock lock(lock_);
   return scroll_offset_;
 }
 
 void RenderThreadManager::SetFrameOnUI(std::unique_ptr<ChildFrame> frame) {
   base::AutoLock lock(lock_);
   DCHECK(!child_frame_.get());
   child_frame_ = std::move(frame);
 }
 
+void RenderThreadManager::SetFrameFutureOnUI(
+    const scoped_refptr<content::SynchronousCompositor::FrameFuture>&
+        frame_future) {
+  frame_future_ = std::move(frame_future);

[boliu, 2016/09/22 23:05:32]

AutoLock

[ojars, 2016/09/28 00:17:59]

Done.

+}
+
 std::unique_ptr<ChildFrame> RenderThreadManager::PassFrameOnRT() {

[boliu, 2016/09/22 23:05:32]

you need to repeat all this code for PassUncommittedFrameOnUI, so factor out
into a method to avoid code duplication

[ojars, 2016/09/28 00:17:58]

Done.

   base::AutoLock lock(lock_);
   hardware_renderer_has_frame_ =
       hardware_renderer_has_frame_ || child_frame_.get();
+  if (async_on_draw_hardware_ && child_frame_.get() &&
+      !child_frame_->frame.get()) {

[boliu, 2016/09/22 23:05:31]

this third part of this check should be a DCHECK instead

[ojars, 2016/09/28 00:17:58]

Done.

+    std::unique_ptr<content::SynchronousCompositor::Frame> frame =
+        frame_future_->getFrame();
+
+    std::unique_ptr<cc::CompositorFrame> compositor_frame =
+        std::move(frame->frame);
+
+    child_frame_ = 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);
+  }
   return std::move(child_frame_);
 }
 
 std::unique_ptr<ChildFrame> RenderThreadManager::PassUncommittedFrameOnUI() {
   base::AutoLock lock(lock_);
   return std::move(child_frame_);
 }
 
 void RenderThreadManager::PostExternalDrawConstraintsToChildCompositorOnRT(
     const ParentCompositorDrawConstraints& parent_draw_constraints) {
@@ skipping 202 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