sync compositor: Signal async frame on IO thread

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 <utility>
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/child_frame.h"
@@ skipping 91 matching lines @@
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
       hardware_enabled_(false),
       dip_scale_(0.f),
       page_scale_factor_(1.f),
       min_page_scale_factor_(0.f),
       max_page_scale_factor_(0.f),
       on_new_picture_enable_(false),
       clear_view_(false),
-      offscreen_pre_raster_(false) {}
+      offscreen_pre_raster_(false),
+      first_sync_frame_(false) {}
 
 BrowserViewRenderer::~BrowserViewRenderer() {
   DCHECK(compositor_map_.empty());
   SetCurrentCompositorFrameConsumer(nullptr);
   while (compositor_frame_consumers_.size()) {
     RemoveCompositorFrameConsumer(*compositor_frame_consumers_.begin());
   }
 }
 
 void BrowserViewRenderer::SetCurrentCompositorFrameConsumer(
@@ skipping 102 matching lines @@
 
   ReturnResourceFromParent(current_compositor_frame_consumer_);
   UpdateMemoryPolicy();
 
   gfx::Transform transform_for_tile_priority =
       external_draw_constraints_.transform;
 
   gfx::Rect viewport_rect_for_tile_priority =
       ComputeViewportRectForTilePriority();
 
-  if (async_on_draw_hardware_) {
-    compositor_->DemandDrawHwAsync(size_, viewport_rect_for_tile_priority,
-                                   transform_for_tile_priority);
-    return current_compositor_frame_consumer_->HasFrameOnUI();
+  scoped_refptr<content::SynchronousCompositor::FrameFuture> future; // Async.
+  content::SynchronousCompositor::Frame frame; // Sync.
+  bool async = async_on_draw_hardware_ && first_sync_frame_;

[dcheng, 2016/10/21 06:42:56]

This might be worth a comment: it's not clear to me why async should be true if
|first_sync_frame_| is true.

[boliu, 2016/10/21 15:15:32]

renamed this to "allow_async_draw_" and added a comment to the header where
there was already a TODO to remove it

+  if (async) {
+    future = compositor_->DemandDrawHwAsync(
+        size_, viewport_rect_for_tile_priority, transform_for_tile_priority);
+  } else {
+    frame = compositor_->DemandDrawHw(size_, viewport_rect_for_tile_priority,
+                                      transform_for_tile_priority);
   }
 
-  content::SynchronousCompositor::Frame frame = compositor_->DemandDrawHw(
-      size_, viewport_rect_for_tile_priority, transform_for_tile_priority);
-  if (!frame.frame) {
+  if (!frame.frame && !future) {

[dcheng, 2016/10/21 06:42:56]

Maybe a comment that documents what this means would be helpful too, though
maybe it's obvious to someone more familiar with the compositor.

[boliu, 2016/10/21 15:15:32]

yeah should generally be clear to compositor folks I think, compositor can
choose to not produce a new frame if it thinks the nothing has changed since the
previous frame

in chrome where things are async, it just doesn't send anything back to the
browser, in webview, the way we implemented it is don't return a frame

     TRACE_EVENT_INSTANT0("android_webview", "NoNewFrame",
                          TRACE_EVENT_SCOPE_THREAD);
     return current_compositor_frame_consumer_->HasFrameOnUI();
   }
 
+  first_sync_frame_ = true;
   std::unique_ptr<ChildFrame> child_frame = base::MakeUnique<ChildFrame>(
       frame.compositor_frame_sink_id, std::move(frame.frame), compositor_id_,
       viewport_rect_for_tile_priority.IsEmpty(), transform_for_tile_priority,
       offscreen_pre_raster_, external_draw_constraints_.is_layer);
 
   ReturnUnusedResource(
       current_compositor_frame_consumer_->PassUncommittedFrameOnUI());
   current_compositor_frame_consumer_->SetFrameOnUI(std::move(child_frame),
-                                                   nullptr);
-
+                                                   future);

[dcheng, 2016/10/21 06:42:56]

Nit: std::move(future)

[boliu, 2016/10/21 15:15:32]

Done.

   return true;
 }
 
-void BrowserViewRenderer::OnDrawHardwareProcessFrameFuture(
-    const scoped_refptr<content::SynchronousCompositor::FrameFuture>&
-        frame_future) {
-  gfx::Transform transform_for_tile_priority =
-      external_draw_constraints_.transform;
-  gfx::Rect viewport_rect_for_tile_priority =
-      ComputeViewportRectForTilePriority();
-
-  ReturnUnusedResource(
-      current_compositor_frame_consumer_->PassUncommittedFrameOnUI());
-  current_compositor_frame_consumer_->SetFrameOnUI(
-      base::MakeUnique<ChildFrame>(
-          0, nullptr, compositor_id_, viewport_rect_for_tile_priority.IsEmpty(),
-          transform_for_tile_priority, offscreen_pre_raster_,
-          external_draw_constraints_.is_layer),
-      frame_future);
-}
-
 gfx::Rect BrowserViewRenderer::ComputeViewportRectForTilePriority() {
   // If the WebView is on a layer, WebView does not know what transform is
   // applied onto the layer so global visible rect does not make sense here.
   // In this case, just use the surface rect for tiling.
   // Leave viewport_rect_for_tile_priority empty if offscreen_pre_raster_ is on.
   gfx::Rect viewport_rect_for_tile_priority;
 
   if (!offscreen_pre_raster_ && !external_draw_constraints_.is_layer) {
     viewport_rect_for_tile_priority = last_on_draw_global_visible_rect_;
   }
@@ skipping 483 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