[Android WebView] Implement Ubercomp for Render Thread support

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 "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/shared_renderer_state.h"
+#include "android_webview/common/aw_switches.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
+#include "cc/output/compositor_frame.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/vector2d_conversions.h"
 
@@ skipping 94 matching lines @@
       shared_renderer_state_(shared_renderer_state),
       web_contents_(web_contents),
       weak_factory_on_ui_thread_(this),
       ui_thread_weak_ptr_(weak_factory_on_ui_thread_.GetWeakPtr()),
       ui_task_runner_(ui_task_runner),
       has_compositor_(false),
       is_paused_(false),
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
+      hardware_enabled_(false),
       dip_scale_(0.0),
       page_scale_factor_(1.0),
       on_new_picture_enable_(false),
       clear_view_(false),
       compositor_needs_continuous_invalidate_(false),
       block_invalidates_(false),
       width_(0),
       height_(0),
       num_tiles_(0u),
       num_bytes_(0u) {
@@ skipping 39 matching lines @@
 
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::TrimMemory");
 
   RequestMemoryPolicy(zero_policy);
   EnforceMemoryPolicyImmediately(zero_policy);
 }
 
 SynchronousCompositorMemoryPolicy
 BrowserViewRenderer::CalculateDesiredMemoryPolicy() {
   SynchronousCompositorMemoryPolicy policy;
-  size_t width = draw_gl_input_.global_visible_rect.width();
-  size_t height = draw_gl_input_.global_visible_rect.height();
+  size_t width = global_visible_rect_.width();
+  size_t height = global_visible_rect_.height();
   policy.bytes_limit = kMemoryMultiplier * kBytesPerPixel * width * height;
   // Round up to a multiple of kMemoryAllocationStep.
   policy.bytes_limit =
       (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
 
   size_t tiles = width * height * kTileMultiplier / g_tile_area;
   // Round up to a multiple of kTileAllocationStep. The minimum number of tiles
   // is also kTileAllocationStep.
   tiles = (tiles / kTileAllocationStep + 1) * kTileAllocationStep;
   policy.num_resources_limit = tiles;
@@ skipping 37 matching lines @@
 
 size_t BrowserViewRenderer::GetNumTiles() const {
   return shared_renderer_state_->GetMemoryPolicy().num_resources_limit;
 }
 
 bool BrowserViewRenderer::OnDraw(jobject java_canvas,
                                  bool is_hardware_canvas,
                                  const gfx::Vector2d& scroll,
                                  const gfx::Rect& global_visible_rect,
                                  const gfx::Rect& clip) {
-  draw_gl_input_.frame_id++;
-  draw_gl_input_.scroll_offset = scroll;
-  draw_gl_input_.global_visible_rect = global_visible_rect;
-  draw_gl_input_.width = width_;
-  draw_gl_input_.height = height_;
+  scroll_offset_ = scroll;
+  global_visible_rect_ = global_visible_rect;
+
   if (clear_view_)
     return false;
+
   if (is_hardware_canvas && attached_to_window_) {
-    shared_renderer_state_->SetDrawGLInput(draw_gl_input_);
-
-    SynchronousCompositorMemoryPolicy old_policy =
-        shared_renderer_state_->GetMemoryPolicy();
-    SynchronousCompositorMemoryPolicy new_policy =
-        CalculateDesiredMemoryPolicy();
-    RequestMemoryPolicy(new_policy);
-    // We should be performing a hardware draw here. If we don't have the
-    // compositor yet or if RequestDrawGL fails, it means we failed this draw
-    // and thus return false here to clear to background color for this draw.
-    bool did_draw_gl =
-        has_compositor_ && client_->RequestDrawGL(java_canvas, false);
-    if (did_draw_gl)
-      GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
-    else
-      RequestMemoryPolicy(old_policy);
-
-    return did_draw_gl;
+    if (switches::UbercompEnabled()) {
+      return OnDrawHardware(java_canvas);
+    } else {
+      return OnDrawHardwareLegacy(java_canvas);
+    }
   }
   // Perform a software draw
   return DrawSWInternal(java_canvas, clip);
 }
 
-void BrowserViewRenderer::DidDrawGL(const DrawGLResult& result) {
-  DidComposite(!result.clip_contains_visible_rect);
+bool BrowserViewRenderer::OnDrawHardwareLegacy(jobject java_canvas) {
+  scoped_ptr<DrawGLInput> draw_gl_input(new DrawGLInput);
+  draw_gl_input->scroll_offset = scroll_offset_;
+  draw_gl_input->global_visible_rect = global_visible_rect_;
+  draw_gl_input->width = width_;
+  draw_gl_input->height = height_;
+
+  SynchronousCompositorMemoryPolicy old_policy =
+      shared_renderer_state_->GetMemoryPolicy();
+  SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
+  RequestMemoryPolicy(new_policy);
+  // We should be performing a hardware draw here. If we don't have the
+  // compositor yet or if RequestDrawGL fails, it means we failed this draw
+  // and thus return false here to clear to background color for this draw.
+  bool did_draw_gl =
+      has_compositor_ && client_->RequestDrawGL(java_canvas, false);
+  if (did_draw_gl) {
+    GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
+    shared_renderer_state_->SetDrawGLInput(draw_gl_input.Pass());
+  } else {
+    RequestMemoryPolicy(old_policy);
+  }
+
+  return did_draw_gl;
+}
+
+void BrowserViewRenderer::DidDrawGL(scoped_ptr<DrawGLResult> result) {
+  DidComposite(!result->clip_contains_visible_rect);
+}
+
+bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
+  if (!has_compositor_)
+    return false;
+
+  scoped_ptr<DrawGLInput> draw_gl_input(new DrawGLInput);
+  draw_gl_input->scroll_offset = scroll_offset_;
+  draw_gl_input->global_visible_rect = global_visible_rect_;
+  draw_gl_input->width = width_;
+  draw_gl_input->height = height_;
+
+  DCHECK(attached_to_window_);

[mkosiba (inactive), 2014/05/19 20:01:16]

nit: I think the consensus is that either you DCHECK or you handle gracefully,
not both.

[boliu, 2014/05/19 23:13:01]

Just checked that this can't actually happen. OnDraw doesn't call
OnDrawHardware(Legacy) unless view is already attached, removed this.

+  if (!hardware_enabled_ && attached_to_window_) {
+    hardware_enabled_ =
+        shared_renderer_state_->GetCompositor()->InitializeHwDraw(NULL);
+    if (hardware_enabled_) {
+      DCHECK(shared_renderer_state_->GetCompositor()->GetShareContext());

[mkosiba (inactive), 2014/05/19 20:01:16]

maybe:
  type share_context =
shared_renderer_state_->GetCompositor()->GetShareContext();
  DCHECK(share_context);
  shared_renderer_state_->SetSharedContext(share_context);

Also, is that a typo in GetShareContext() ? Should it be GetSharedContext?

[boliu, 2014/05/19 23:13:01]

Done
Not a typo.

It's actually "from GL", "share group" is a real GL name, and "share context" is
chromium command buffer's immitation of share group.

+      shared_renderer_state_->SetSharedContext(
+          shared_renderer_state_->GetCompositor()->GetShareContext());
+    }
+  }
+  if (!hardware_enabled_)
+    return false;
+
+  ReturnResources();

[mkosiba (inactive), 2014/05/19 20:01:16]

is it possible for the renderer thread to try and do a draw after this but
before DemandDrawHw and is that a potential problem?

[boliu, 2014/05/19 23:13:01]

ReturnResources only return the resources that the parent compositor has
released already. Parent won't release resources that it still needs, and is of
course is free to keep drawing any time it want with them.

This is why there are concerns about doubling memory usage (or halving our
memory limit). Haven't looked closely at this yet.

+  SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
+  RequestMemoryPolicy(new_policy);
+  shared_renderer_state_->GetCompositor()->SetMemoryPolicy(
+      shared_renderer_state_->GetMemoryPolicy());
+
+  gfx::Transform transform;
+  gfx::Size surface_size(width_, height_);
+  gfx::Rect viewport(surface_size);
+  gfx::Rect clip = viewport;  // Should really be global_visible_rect_.
+  bool stencil_enabled = false;
+  bool drew_delegated = shared_renderer_state_->GetCompositor()->DemandDrawHw(
+      surface_size,
+      transform,
+      viewport,
+      clip,
+      stencil_enabled,
+      &draw_gl_input->frame);
+  if (!drew_delegated)
+    return false;
+
+  GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
+
+  scoped_ptr<DrawGLInput> old_input = shared_renderer_state_->PassDrawGLInput();
+  if (old_input.get()) {
+    shared_renderer_state_->ReturnResources(
+        old_input->frame.delegated_frame_data->resource_list);
+  }
+  shared_renderer_state_->SetDrawGLInput(draw_gl_input.Pass());
+
+  DidComposite(false);
+  bool did_request = client_->RequestDrawGL(java_canvas, false);
+  if (did_request)
+    return true;
+
+  ReturnResources();
+  return false;
+}
+
+void BrowserViewRenderer::DidDrawDelegated(scoped_ptr<DrawGLResult> result) {
+  if (!ui_task_runner_->BelongsToCurrentThread()) {
+    // TODO(boliu): This should be a cancelable callback.
+    ui_task_runner_->PostTask(FROM_HERE,
+                              base::Bind(&BrowserViewRenderer::DidDrawDelegated,
+                                         ui_thread_weak_ptr_,
+                                         base::Passed(&result)));
+    return;
+  }
+  ReturnResources();
+}
+
+void BrowserViewRenderer::ReturnResources() {
+  cc::CompositorFrameAck frame_ack;
+  shared_renderer_state_->SwapReturnedResources(&frame_ack.resources);

[mkosiba (inactive), 2014/05/19 20:01:16]

It seems like this logic could just live in the shared_renderer_state? I know it
doesn't do any logic now but you have a couple of places where you simply "get"
things out of one thing accessible from the shared_renderer_state to "set" them
on another thing accessible from the shared_renderer_state.

[boliu, 2014/05/19 23:13:01]

Once legacy path is removed, SharedRendererState won't have a pointer to the
child SynchronousCompositor anymore.

+  if (!frame_ack.resources.empty()) {
+    shared_renderer_state_->GetCompositor()->ReturnResources(frame_ack);
+  }
 }
 
 bool BrowserViewRenderer::DrawSWInternal(jobject java_canvas,
                                          const gfx::Rect& clip) {
   if (clip.IsEmpty()) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_EmptyClip", TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   if (!has_compositor_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   return BrowserViewRendererJavaHelper::GetInstance()
       ->RenderViaAuxilaryBitmapIfNeeded(
             java_canvas,
-            draw_gl_input_.scroll_offset,
+            scroll_offset_,
             clip,
             base::Bind(&BrowserViewRenderer::CompositeSW,
                        base::Unretained(this)));
 }
 
 skia::RefPtr<SkPicture> BrowserViewRenderer::CapturePicture(int width,
                                                             int height) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::CapturePicture");
 
   // Return empty Picture objects for empty SkPictures.
@@ skipping 79 matching lines @@
                height);
   attached_to_window_ = true;
   width_ = width;
   height_ = height;
   tile_manager_key_ = GlobalTileManager::GetInstance()->PushBack(this);
 }
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   attached_to_window_ = false;
+  if (hardware_enabled_) {
+    scoped_ptr<DrawGLInput> input = shared_renderer_state_->PassDrawGLInput();
+    if (input.get()) {
+      shared_renderer_state_->ReturnResources(
+          input->frame.delegated_frame_data->resource_list);
+    }
+    ReturnResources();
+    DCHECK(shared_renderer_state_->ReturnedResourcesEmpty());
+
+    if (switches::UbercompEnabled())
+      shared_renderer_state_->GetCompositor()->ReleaseHwDraw();
+    shared_renderer_state_->SetSharedContext(NULL);
+    hardware_enabled_ = false;
+  }
   SynchronousCompositorMemoryPolicy zero_policy;
   RequestMemoryPolicy(zero_policy);
   GlobalTileManager::GetInstance()->Remove(tile_manager_key_);
   // The hardware resources are released in the destructor of hardware renderer,
   // so we don't need to do it here.
   // See AwContents::ReleaseHardwareDrawOnRenderThread(JNIEnv*, jobject).
 }
 
 bool BrowserViewRenderer::IsAttachedToWindow() const {
   return attached_to_window_;
@@ skipping 361 matching lines @@
   base::StringAppendF(&str, "dip_scale: %f ", dip_scale_);
   base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_);
   base::StringAppendF(&str,
                       "compositor_needs_continuous_invalidate: %d ",
                       compositor_needs_continuous_invalidate_);
   base::StringAppendF(&str, "block_invalidates: %d ", block_invalidates_);
   base::StringAppendF(&str, "view width height: [%d %d] ", width_, height_);
   base::StringAppendF(&str, "attached_to_window: %d ", attached_to_window_);
   base::StringAppendF(&str,
                       "global visible rect: %s ",
-                      draw_gl_input_.global_visible_rect.ToString().c_str());
+                      global_visible_rect_.ToString().c_str());
   base::StringAppendF(
       &str, "scroll_offset_dip: %s ", scroll_offset_dip_.ToString().c_str());
   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_);
   if (draw_info) {
     base::StringAppendF(&str,
                         "clip left top right bottom: [%d %d %d %d] ",
                         draw_info->clip_left,
                         draw_info->clip_top,
                         draw_info->clip_right,
                         draw_info->clip_bottom);
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview