[Android WebView] Implement Ubercomp for Render Thread support

content/browser/android/in_process/synchronous_compositor_output_surface.cc

 // Copyright 2013 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 "content/browser/android/in_process/synchronous_compositor_output_surface.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #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"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace content {
 
@@ skipping 42 matching lines @@
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
     int routing_id)
     : cc::OutputSurface(
           scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
       routing_id_(routing_id),
       needs_begin_frame_(false),
       invoking_composite_(false),
       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.
 
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {
   DCHECK(CalledOnValidThread());
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
@@ skipping 40 matching lines @@
     delegate->SetContinuousInvalidate(needs_begin_frame_);
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame* frame) {
   DCHECK(CalledOnValidThread());
   if (!ForcedDrawToSoftwareDevice()) {
     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.
   transform->matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
 }
 } // namespace
 
 bool SynchronousCompositorOutputSurface::InitializeHwDraw(
     scoped_refptr<cc::ContextProvider> onscreen_context_provider) {
   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
   DCHECK(!context_provider_);
 
   return InitializeAndSetContext3d(onscreen_context_provider);
 }
 
 void SynchronousCompositorOutputSurface::ReleaseHwDraw() {
   DCHECK(CalledOnValidThread());
   cc::OutputSurface::ReleaseGL();
 }
 
 bool SynchronousCompositorOutputSurface::DemandDrawHw(
     gfx::Size surface_size,
     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);
 
   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;
   canvas->getClipDeviceBounds(&canvas_clip);
   gfx::Rect clip = gfx::SkIRectToRect(canvas_clip);
 
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix() = canvas->getTotalMatrix();  // Converts 3x3 matrix to 4x4.
 
   surface_size_ = gfx::Size(canvas->getDeviceSize().width(),
@@ skipping 34 matching lines @@
   }
 
   if (did_swap_buffer_)
     client_->DidSwapBuffersComplete();
 
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->SetContinuousInvalidate(needs_begin_frame_);
 }
 
+void SynchronousCompositorOutputSurface::ReturnResources(
+    const cc::CompositorFrameAck& frame_ack) {
+  ReclaimResources(&frame_ack);
+}
+
 void SynchronousCompositorOutputSurface::SetMemoryPolicy(
     const SynchronousCompositorMemoryPolicy& policy) {
   DCHECK(CalledOnValidThread());
   memory_policy_.bytes_limit_when_visible = policy.bytes_limit;
   memory_policy_.num_resources_limit = policy.num_resources_limit;
 
   if (output_surface_client_)
     output_surface_client_->SetMemoryPolicy(memory_policy_);
 }
 
 // Not using base::NonThreadSafe as we want to enforce a more exacting threading
 // requirement: SynchronousCompositorOutputSurface() must only be used on the UI
 // thread.
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 SynchronousCompositorOutputSurfaceDelegate*
 SynchronousCompositorOutputSurface::GetDelegate() {
   return SynchronousCompositorImpl::FromRoutingID(routing_id_);
 }
 
 }  // namespace content