[Android WebView] Implement Ubercomp for Render Thread support

content/browser/android/in_process/synchronous_compositor_output_surface.cc

Index: content/browser/android/in_process/synchronous_compositor_output_surface.cc
diff --git a/content/browser/android/in_process/synchronous_compositor_output_surface.cc b/content/browser/android/in_process/synchronous_compositor_output_surface.cc
index de609c3c7eb1a80fef535c4a6482c75afd5eae46..fb7f2fd6dc68392b40dc478ed235b07e4e85c897 100644
--- a/content/browser/android/in_process/synchronous_compositor_output_surface.cc
+++ b/content/browser/android/in_process/synchronous_compositor_output_surface.cc
@@ -12,6 +12,7 @@
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
+#include "content/browser/gpu/compositor_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
@@ -74,11 +75,14 @@ SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
       did_swap_buffer_(false),
       current_sw_canvas_(NULL),
       memory_policy_(0),
-      output_surface_client_(NULL),
-      weak_ptr_factory_(this) {
+      output_surface_client_(NULL) {
   capabilities_.deferred_gl_initialization = true;
   capabilities_.draw_and_swap_full_viewport_every_frame = true;

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

Is this still needed here then? The browser side is setting it.

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

Still needed for software path, which child compositor still draws directly "to
screen" (bitmap from android which is immdiately put on screen).

If we ignore the software path, then we can make an argument that this won't be
needed.

   capabilities_.adjust_deadline_for_parent = false;

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

Still needed?

[boliu, 2014/05/21 19:58:22]

Yes. This is to avoid enabling part of the deadline scheduler I believe. Webview
does not control draw scheduling, and has BeginImplFrame and
BeginImplFrameDeadline be the same call.

[danakj, 2014/05/21 20:01:01]

This is true for the browser compositor, but is that still true for the
renderer? How will the renderer produce frames? Is it synchronous within the
browser compositor's draw functor?

[boliu, 2014/05/21 20:12:20]

This renderer compositor still needs to be synchronous, regardless if it's for
ubercomp or resourceless software or the existing hardware path. It's because
the new frame must be produced to take into account the scroll offset (and
matrix). Otherwise for example in the gmail android app, the email might not
scroll in sync with email header.

For delegated rendering, renderer compositor draw maps to onDraw on UI, and
parent compositor draw maps to draw functor on RT. onDraw and functor can happen
asynchronously, but "how asynchronous" is out of our control, as we don't
control the callsite of either function.

Hope this makes sense?

[danakj, 2014/05/21 20:13:39]

Oh ok. Ya, I bumped into onDraw in the removal of CompositeAndReadback :)

+  if (IsDelegatedRendererEnabled()) {
+    capabilities_.delegated_rendering = true;
+    capabilities_.max_frames_pending = 1;
+  }
   // Cannot call out to GetDelegate() here as the output surface is not
   // constructed on the correct thread.
 
@@ -139,29 +143,14 @@ void SynchronousCompositorOutputSurface::SwapBuffers(
     DCHECK(context_provider_);
     context_provider_->ContextGL()->ShallowFlushCHROMIUM();
   }
-  UpdateFrameMetaData(frame->metadata);
+
+  DCHECK(frame_);
+  frame->AssignTo(frame_);
 
   did_swap_buffer_ = true;
   client_->DidSwapBuffers();
 }
 
-void SynchronousCompositorOutputSurface::UpdateFrameMetaData(
-    const cc::CompositorFrameMetadata& frame_info) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&SynchronousCompositorOutputSurface::UpdateFrameMetaData,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   frame_info));
-    return;
-  }
-
-  SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
-  if (delegate)
-    delegate->UpdateFrameMetaData(frame_info);
-}
-
 namespace {
 void AdjustTransform(gfx::Transform* transform, gfx::Rect viewport) {
   // CC's draw origin starts at the viewport.
@@ -188,11 +177,13 @@ bool SynchronousCompositorOutputSurface::DemandDrawHw(
     const gfx::Transform& transform,
     gfx::Rect viewport,
     gfx::Rect clip,
-    bool stencil_enabled) {
+    bool stencil_enabled,
+    cc::CompositorFrame* frame) {

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

It feels a bit awkward to be passing in a CompositorFrame* and storing it for
SwapBuffers to assign to.

What if SwapBuffers simply stored the scoped_ptr of the frame on this class, and
then DemandDrawHw returned a scoped_ptr<CompositorFrame> instead of a bool? Then
we don't have some slightly-awkward raw pointers going on, and can follow the
path of things more easily?

DemandDrawSw could return the same. WDYT?

   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
   DCHECK(context_provider_);
 
+  base::AutoReset<cc::CompositorFrame*> frame_resetter(&frame_, frame);
   surface_size_ = surface_size;
   SetExternalStencilTest(stencil_enabled);
   InvokeComposite(transform, viewport, clip, true);
@@ -200,10 +191,13 @@ bool SynchronousCompositorOutputSurface::DemandDrawHw(
   return did_swap_buffer_;
 }
 
-bool SynchronousCompositorOutputSurface::DemandDrawSw(SkCanvas* canvas) {
+bool SynchronousCompositorOutputSurface::DemandDrawSw(
+    SkCanvas* canvas,
+    cc::CompositorFrame* frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(canvas);
   DCHECK(!current_sw_canvas_);
+  base::AutoReset<cc::CompositorFrame*> frame_resetter(&frame_, frame);
   base::AutoReset<SkCanvas*> canvas_resetter(&current_sw_canvas_, canvas);
 
   SkIRect canvas_clip;
@@ -258,6 +252,11 @@ void SynchronousCompositorOutputSurface::InvokeComposite(
     delegate->SetContinuousInvalidate(needs_begin_frame_);
 }
 
+void SynchronousCompositorOutputSurface::ReturnResources(
+    const cc::CompositorFrameAck& frame_ack) {
+  ReclaimResources(&frame_ack);
+}
+
 void SynchronousCompositorOutputSurface::SetMemoryPolicy(
     const SynchronousCompositorMemoryPolicy& policy) {
   DCHECK(CalledOnValidThread());