OnDrawHardware() implementation with async messages

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"
 #include "android_webview/browser/compositor_frame_consumer.h"
+#include "android_webview/common/aw_switches.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/supports_user_data.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/compositor_frame.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 64 matching lines @@
 BrowserViewRenderer* BrowserViewRenderer::FromWebContents(
     content::WebContents* web_contents) {
   return BrowserViewRendererUserData::GetBrowserViewRenderer(web_contents);
 }
 
 BrowserViewRenderer::BrowserViewRenderer(
     BrowserViewRendererClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)
     : client_(client),
       ui_task_runner_(ui_task_runner),
+      async_on_draw_hardware_(base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAsyncOnDrawHardware)),
       current_compositor_frame_consumer_(nullptr),
       compositor_(nullptr),
       is_paused_(false),
       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),
@@ skipping 123 matching lines @@
   // 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.
   gfx::Rect viewport_rect_for_tile_priority;
 
   // Leave viewport_rect_for_tile_priority empty if offscreen_pre_raster_ is on.
   if (!offscreen_pre_raster_ && !external_draw_constraints_.is_layer) {
     viewport_rect_for_tile_priority = last_on_draw_global_visible_rect_;
   }
 
+  if (async_on_draw_hardware_) {
+    compositor_->DemandDrawHwAsync(size_, viewport_rect_for_tile_priority,
+                                   transform_for_tile_priority);
+    return current_compositor_frame_consumer_->HasFrameOnUI();
+  }
+
   content::SynchronousCompositor::Frame frame = compositor_->DemandDrawHw(
       size_, viewport_rect_for_tile_priority, transform_for_tile_priority);
-  if (!frame.frame.get()) {
-    TRACE_EVENT_INSTANT0("android_webview", "NoNewFrame",
-                         TRACE_EVENT_SCOPE_THREAD);
+
+  if (!frame.frame.get())
     return current_compositor_frame_consumer_->HasFrameOnUI();

[boliu, 2016/08/23 22:08:01]

there used to be an TRACE_EVENT_INSTANT0 here, don't drop it

[ojars, 2016/08/29 21:54:45]

Done.

+
+  OnDrawHardwareProcessFrame(std::move(frame));
+  return true;
+}
+
+void BrowserViewRenderer::OnDrawHardwareProcessFrame(
+    content::SynchronousCompositor::Frame frame) {
+  TRACE_EVENT0("android_webview",
+               "BrowserViewRenderer::OnDrawHardwareProcessFrame");
+  if (!frame.frame.get())
+    return;
+
+  gfx::Transform transform_for_tile_priority =
+      external_draw_constraints_.transform;
+  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_;

[boliu, 2016/08/23 22:08:01]

factor this duplicate code into a helper method, like
ComputeViewportRectForTilePriority

[ojars, 2016/08/29 21:54:45]

Done.

   }
 
   std::unique_ptr<ChildFrame> child_frame = base::WrapUnique(new ChildFrame(
       frame.output_surface_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));
-  return true;
 }
 
 void BrowserViewRenderer::OnParentDrawConstraintsUpdated(
     CompositorFrameConsumer* compositor_frame_consumer) {
   DCHECK(compositor_frame_consumer);
   if (compositor_frame_consumer != current_compositor_frame_consumer_)
     return;
   PostInvalidate(compositor_);
   external_draw_constraints_ =
       current_compositor_frame_consumer_->GetParentDrawConstraintsOnUI();
@@ skipping 466 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