[Android WebView] Implement Ubercomp for Render Thread support

android_webview/browser/hardware_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/hardware_renderer.h"
 
 #include "android_webview/browser/aw_gl_surface.h"
-#include "android_webview/browser/browser_view_renderer_client.h"
+#include "android_webview/browser/deferred_gpu_command_service.h"
+#include "android_webview/browser/parent_output_surface.h"
+#include "android_webview/browser/shared_renderer_state.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
-#include "content/public/browser/android/synchronous_compositor.h"
-#include "content/public/browser/browser_thread.h"
-#include "gpu/command_buffer/service/shader_translator_cache.h"
+#include "cc/layers/delegated_frame_provider.h"
+#include "cc/layers/delegated_renderer_layer.h"
+#include "cc/layers/layer.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/output/output_surface.h"
+#include "cc/trees/layer_tree_host.h"
+#include "cc/trees/layer_tree_settings.h"
+#include "gpu/command_buffer/client/gl_in_process_context.h"
+#include "ui/gfx/frame_time.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_bindings.h"
+#include "webkit/common/gpu/context_provider_in_process.h"
+#include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 namespace android_webview {
 
+namespace {
+
+using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
+
+scoped_refptr<cc::ContextProvider> CreateContext(
+    scoped_refptr<gfx::GLSurface> surface,
+    scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
+    gpu::GLInProcessContext* share_context) {
+  const gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
+
+  blink::WebGraphicsContext3D::Attributes attributes;
+  attributes.antialias = false;
+  attributes.depth = false;
+  attributes.stencil = false;
+  attributes.shareResources = true;
+  attributes.noAutomaticFlushes = true;
+  gpu::GLInProcessContextAttribs in_process_attribs;
+  WebGraphicsContext3DInProcessCommandBufferImpl::ConvertAttributes(
+      attributes, &in_process_attribs);
+  in_process_attribs.lose_context_when_out_of_memory = 1;
+
+  scoped_ptr<gpu::GLInProcessContext> context(
+      gpu::GLInProcessContext::Create(service,
+                                      surface,
+                                      surface->IsOffscreen(),
+                                      gfx::kNullAcceleratedWidget,
+                                      surface->GetSize(),
+                                      share_context,
+                                      false /* share_resources */,
+                                      in_process_attribs,
+                                      gpu_preference));
+  DCHECK(context.get());
+
+  return webkit::gpu::ContextProviderInProcess::Create(
+      WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
+          context.Pass(), attributes),
+      "Parent-Compositor");
+}
+
+}  // namespace
+
 HardwareRenderer::HardwareRenderer(SharedRendererState* state)
     : shared_renderer_state_(state),
-      last_egl_context_(eglGetCurrentContext()) {
+      last_egl_context_(eglGetCurrentContext()),
+      view_width_(-1),
+      view_height_(-1),
+      root_layer_(cc::Layer::Create()) {
   DCHECK(last_egl_context_);
 
+  root_layer_->SetIsDrawable(false);

[danakj, 2014/05/20 21:50:02]

this is the default already

[boliu, 2014/05/21 01:33:26]

Done.

+
   gl_surface_ = new AwGLSurface;
-  bool success =
-      shared_renderer_state_->GetCompositor()->
-          InitializeHwDraw(gl_surface_);
-  DCHECK(success);
+
+  cc::LayerTreeSettings settings;
+
+  // Copied from compositor_impl_android.cc.

[danakj, 2014/05/20 21:50:02]

Maybe you want a "Keep in sync with compositor_impl_android.cc" ? And throw a
similar comment over there?

+  settings.refresh_rate = 60.0;
+  settings.impl_side_painting = false;
+  settings.allow_antialiasing = false;
+  settings.calculate_top_controls_position = false;

[danakj, 2014/05/20 21:50:02]

this is the default, should remove in both places?

+  settings.top_controls_height = 0.f;

[danakj, 2014/05/20 21:50:02]

ditto

+  settings.highp_threshold_min = 2048;
+
+  // Android WebView uses system scrollbars, so make ours invisible.
+  settings.scrollbar_animator = cc::LayerTreeSettings::NoAnimator;

[danakj, 2014/05/20 21:50:02]

ditto, also there are scrollbars in the browser compositor? probably not?

[boliu, 2014/05/21 01:33:26]

No scroll bar layers in parent compositor, removed.

+  settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
+
+  // Webview does not own the surface so should not clear it.
+  settings.should_clear_root_render_pass = false;
+
+  layer_tree_host_ =
+      cc::LayerTreeHost::CreateSingleThreaded(this, this, NULL, settings);

[danakj, 2014/05/20 21:50:02]

you need a non-NULL HostSharedMemoryManager here. Since this isn't actually IPC,
we could maybe have a different manager and child manager pair that don't use
shared memory just fake it.

without a manager here software mode ubercomp is going to blow up (i hope)

[boliu, 2014/05/21 01:33:26]

Ubercomp in webview is guaranteed to be hardware only. Software doesn't change
at all with ubercomp, and still uses the resourceless software draw path in
child compositor.

[danakj, 2014/05/21 15:22:54]

What about non-resourceless software mode before you initialize the deferred GL?
Do we actually never draw in that state?

[boliu, 2014/05/21 15:35:14]

Right, webview either does resourceless software draws, or full hardware draws.
We never do a delegated software frame.

The Renderer in LTHI *before* deferred GL initialize is just a placeholder
that's never used to draw.

[danakj, 2014/05/21 15:36:32]

Ohmygosh, I never even realized that. Ok thanks for the explanation!

+  layer_tree_host_->SetRootLayer(root_layer_);
+  layer_tree_host_->SetLayerTreeHostClientReady();
+
+  scoped_refptr<cc::ContextProvider> context_provider =
+      CreateContext(gl_surface_,
+                    DeferredGpuCommandService::GetInstance(),
+                    shared_renderer_state_->GetSharedContext());
+  output_surface_holder_.reset(new ParentOutputSurface(context_provider));
+  output_surface_ = output_surface_holder_->GetWeakPtr();
 }
 
 HardwareRenderer::~HardwareRenderer() {
-  shared_renderer_state_->GetCompositor()->ReleaseHwDraw();
-  gl_surface_ = NULL;
+  layer_tree_host_->SetRootLayer(NULL);

[danakj, 2014/05/20 21:50:02]

not really needed

[boliu, 2014/05/21 01:33:26]

Removed.

+  layer_tree_host_.reset();
+  root_layer_->RemoveAllChildren();

[danakj, 2014/05/20 21:50:02]

why?

[boliu, 2014/05/21 01:33:26]

Want to ensure DelegatedRendererLayer, which is a child of the root layer, to be
destroyed before SetClient(NULL) below.

Updated the comment, and just reset to everything to NULL instead. There are no
circular ref-counting in layer tree :)

+
+  // Order is important to ensure all resources are returned.
+  layer_ = NULL;
+  frame_provider_ = NULL;
+  if (resource_collection_.get()) {
+#if DCHECK_IS_ON
+    // Check collection is empty.
+    cc::ReturnedResourceArray returned_resources;
+    resource_collection_->TakeUnusedResourcesForChildCompositor(
+        &returned_resources);
+    DCHECK(returned_resources.empty());

[danakj, 2014/05/20 21:50:02]

nit: DCHECK_EQ(0, size()) gives you more data if it fails.. since it's supposed
to be empty this shouldn't be more costly than empty()?

[boliu, 2014/05/21 01:33:26]

Done.

+#endif  // DCHECK_IS_ON
+
+    resource_collection_->SetClient(NULL);
+  }
 }
 
 bool HardwareRenderer::DrawGL(bool stencil_enabled,
                               int framebuffer_binding_ext,
                               AwDrawGLInfo* draw_info,
                               DrawGLResult* result) {
   TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL");
 
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   if (!current_context) {
     DLOG(ERROR) << "DrawGL called without EGLContext";
     return false;
   }
 
   // TODO(boliu): Handle context loss.
   if (last_egl_context_ != current_context)
     DLOG(WARNING) << "EGLContextChanged";
 
-  if (draw_info->mode != AwDrawGLInfo::kModeDraw)
-    return false;
+  scoped_ptr<DrawGLInput> input = shared_renderer_state_->PassDrawGLInput();
+  if (!resource_collection_.get()) {
+    resource_collection_ = new cc::DelegatedFrameResourceCollection;
+    resource_collection_->SetClient(this);
+  }
 
-  // Should only need to access SharedRendererState in kModeDraw and kModeSync.
-  const DrawGLInput input = shared_renderer_state_->GetDrawGLInput();
-  SetCompositorMemoryPolicy();
+  if (input.get()) {
+    DCHECK(!input->frame.gl_frame_data);
+    DCHECK(!input->frame.software_frame_data);
 
-  gl_surface_->SetBackingFrameBufferObject(framebuffer_binding_ext);
+    bool size_changed =
+        input->width != view_width_ || input->height != view_height_;
+    view_width_ = input->width;
+    view_height_ = input->height;
+    scroll_offset_ = input->scroll_offset;
 
-  gfx::Transform transform;
-  transform.matrix().setColMajorf(draw_info->transform);
-  transform.Translate(input.scroll_offset.x(), input.scroll_offset.y());
+    if (!frame_provider_ || size_changed) {
+      if (layer_) {
+        layer_->RemoveFromParent();
+      }
+
+      frame_provider_ = new cc::DelegatedFrameProvider(
+          resource_collection_.get(), input->frame.delegated_frame_data.Pass());
+
+      layer_ = cc::DelegatedRendererLayer::Create(frame_provider_);
+      layer_->SetBounds(gfx::Size(view_width_, view_height_));
+      layer_->SetIsDrawable(true);
+      layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
+
+      root_layer_->AddChild(layer_);
+    } else {
+      frame_provider_->SetFrameData(input->frame.delegated_frame_data.Pass());
+    }
+  }
+
+  gfx::Size viewport(draw_info->width, draw_info->height);
+  layer_tree_host_->SetViewportSize(viewport);
   gfx::Rect clip_rect(draw_info->clip_left,
                       draw_info->clip_top,
                       draw_info->clip_right - draw_info->clip_left,
                       draw_info->clip_bottom - draw_info->clip_top);
+  DCHECK(output_surface_);
+  if (output_surface_) {

[no sievers, 2014/05/20 20:48:26]

Either DCHECK() or if

[danakj, 2014/05/20 21:50:02]

Why do we need a weakptr here. If the OutputSurface is destroyed, that's because
either the compositor is destroyed (can't happen), or we got to
CreateOutputSurface() a 2nd time.

Things stop drawing at that point, can we just set a bool and early out of this
method in that case instead of using a weakptr and calling Composite() which
will never work anyways.

Actually after 5 tries to Composite() cc will LOG(FATAL).

[boliu, 2014/05/21 01:33:26]

DCHECK.
So already stated below in that we do not support losing OutputSurface.

Weakptr is really just for the benefit of the DCHECK. It's not possible to get
draw in the middle of init or tear down.
We DCHECK way earlier :)

+    output_surface_->SetDrawConstraints(viewport, clip_rect);

[danakj, 2014/05/20 21:50:02]

future: maybe we could make these inputs to Composite() or something, instead of
having CC pull them off the OutputSurface.

[boliu, 2014/05/21 01:33:26]

Hmm, this is mirroring how webview sets the viewport/clip information in the
child compositor, and it will still be needed for child compositor even after
ubercomp is turned on. So adding it to Composite for single thread only is kind
of duplicating a code path.

For webview viewport/clip (both here and in child compositor) are not
necessarily same as view_width/length

[danakj, 2014/05/21 15:22:54]

Ah, it wasn't clear that the renderer would still need this stuff.

+  }
+  gfx::Transform transform(gfx::Transform::kSkipInitialization);
+  transform.matrix().setColMajorf(draw_info->transform);
+  transform.Translate(scroll_offset_.x(), scroll_offset_.y());
+  layer_->SetTransform(transform);
 
-  gfx::Rect viewport(draw_info->width, draw_info->height);
-  if (!draw_info->is_layer) {
-    gfx::RectF view_rect(input.width, input.height);
-    transform.TransformRect(&view_rect);
-    viewport.Intersect(gfx::ToEnclosingRect(view_rect));
-  }
-
-  bool did_draw = shared_renderer_state_->GetCompositor()->DemandDrawHw(
-      gfx::Size(draw_info->width, draw_info->height),
-      transform,
-      viewport,
-      clip_rect,
-      stencil_enabled);
+  gl_surface_->SetBackingFrameBufferObject(framebuffer_binding_ext);
+  layer_tree_host_->Composite(gfx::FrameTime::Now());
   gl_surface_->ResetBackingFrameBufferObject();
 
-  if (did_draw) {
-    result->frame_id = input.frame_id;
-    result->clip_contains_visible_rect =
-        clip_rect.Contains(input.global_visible_rect);
-  }
-  return did_draw;
+  return true;
 }
 
-void HardwareRenderer::SetCompositorMemoryPolicy() {
-  if (shared_renderer_state_->IsMemoryPolicyDirty()) {
-    content::SynchronousCompositorMemoryPolicy policy =
-        shared_renderer_state_->GetMemoryPolicy();
-    // Memory policy is set by BrowserViewRenderer on UI thread.
-    shared_renderer_state_->GetCompositor()->SetMemoryPolicy(policy);
-    shared_renderer_state_->SetMemoryPolicyDirty(false);
-  }
+scoped_ptr<cc::OutputSurface> HardwareRenderer::CreateOutputSurface(
+    bool fallback) {
+  // Android webview does not lose output surface.

[no sievers, 2014/05/20 20:48:26]

nit: does not *support* losing the output surface

[boliu, 2014/05/21 01:33:26]

Heh, ok.

+  DCHECK(!fallback);
+  DCHECK(output_surface_holder_.get());
+  return output_surface_holder_.PassAs<cc::OutputSurface>();
+}
+
+void HardwareRenderer::UnusedResourcesAreAvailable() {
+  cc::ReturnedResourceArray returned_resources;
+  resource_collection_->TakeUnusedResourcesForChildCompositor(
+      &returned_resources);
+  shared_renderer_state_->InsertReturnedResources(returned_resources);
 }
 
 }  // namespace android_webview