Android WebView Merged-Thread Hardware Draw

content/renderer/android/synchronous_compositor_output_surface.cc

 // Copyright (c) 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/renderer/android/synchronous_compositor_output_surface.h"
 
 #include "base/logging.h"
+#include "base/time.h"
 #include "cc/output/output_surface_client.h"
-#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/public/renderer/android/synchronous_compositor_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
+#include "webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
+
+using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
 
 namespace content {
+namespace {
+
+// TODO(boliu): RenderThreadImpl should create in process contexts as well.
+scoped_ptr<WebKit::WebGraphicsContext3D> CreateWebGraphicsContext3D() {

[boliu, 2013/05/07 14:13:03]

Here is my plan to support cc hardware init: Move
LayerTreeHostClient::OffscreenContextProviderForMainThread and
OffscreenContextProviderForCompositorThread to OutputSurface interface instead.
Simply call it in LTHI::InitializeRenderer and pass it to
ResourceProvider::set_offscreen_context_provider.

Then remove all the other places for checking/setting the offscreen context. And
the output surface is responsible for reporting the offscreen is context is lost
and report back to cc like the output surface is lost.

This way, all the objects required for hardware init will already be avaiable on
the compositor thread after software is initialized.

James: Do you see any problems with this approach?

Also can I leave this patch as is, since RenderThreadImpl is tightly coupled
with PlatformContext3DImpl which expects a non-in-process command buffer
context.

[danakj, 2013/05/07 18:55:06]

The problem I see here is we only create the offscreen context if we need to.
They are somewhat heavy, so making a useless offscreen context for every
compositor is not desired. This is why it is a part of the BeginFrame() flow,
where we create it the first time we see we need it on the main thread, and then
just recreate it from then on when we lose contexts.

[danakj, 2013/05/07 18:57:11]

Also keep in mind that context creation needs to be done on the main thread.

[boliu, 2013/05/07 19:18:44]

This is the exact behavior I'm trying to workaround for webview, that given a
output_surface that has already been initialized for software draw,
synchronously initialize the hardware bits on the impl thread such that upon
returning, cc is ready to make hardware draws.

Why does context creation need to happen on main thread? Does that restriction
only apply to the cross-process command buffer context? I can't think of
anything in the in-process one that won't work.

Also the offscreen context is created unconditionally in BeginFrame (when using
a GLRenderer). Of course OutputSurface should only create and then reuse one
global offscreen context,  as before, so I think this bit is the same. One
difference is that InitializeRenderer is called while both threads are blocked,
and BeginFrame does not block the compositor thread. I think compositor thread
won't be doing useful work before the first BeginFrame succeeds, right?

[danakj, 2013/05/07 19:35:34]

This is true, it would only be required for the gpu process version I believe,
as it's needed to set up the IPC channel. But then, cc/ doesn't have a clue
about the underlying implementation of WGC3D..
It's not unconditional, it depends on
layer_tree_host_->needs_offscreen_context().

There is one global one, per renderer process. But that is still too many if
we're not using them they are waste.

+  WebKit::WebGraphicsContext3D::Attributes attributes;
+  attributes.antialias = false;
+  attributes.shareResources = true;
+  attributes.noAutomaticFlushes = true;
+
+  return scoped_ptr<WebKit::WebGraphicsContext3D>(
+      WebGraphicsContext3DInProcessCommandBufferImpl
+          ::CreateViewContext(attributes, NULL));
+}
+} // namespace
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
-    int32 routing_id,
-    WebGraphicsContext3DCommandBufferImpl* context)
-    : cc::OutputSurface(scoped_ptr<WebKit::WebGraphicsContext3D>(context)),
+    int32 routing_id)
+    : cc::OutputSurface(CreateWebGraphicsContext3D()),
       compositor_client_(NULL),
-      routing_id_(routing_id) {
-  // WARNING: may be called on any thread.
+      routing_id_(routing_id),
+      did_swap_buffer_(false) {
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {
   DCHECK(CalledOnValidThread());
   if (compositor_client_)
     compositor_client_->DidDestroyCompositor(this);
 }
 
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
   GetContentClient()->renderer()->DidCreateSynchronousCompositor(routing_id_,
                                                                  this);
   return true;
 }
 
+void SynchronousCompositorOutputSurface::Reshape(gfx::Size size) {
+  // Intentional no-op.
+}
+
 void SynchronousCompositorOutputSurface::SendFrameToParentCompositor(
     cc::CompositorFrame* frame) {
   // Intentional no-op: see http://crbug.com/237006
 }
 
+void SynchronousCompositorOutputSurface::EnableVSyncNotification(
+    bool enable_vsync) {
+  DCHECK(CalledOnValidThread());
+  vsync_enabled_ = enable_vsync;
+  UpdateCompositorClientSettings();
+}
+
+void SynchronousCompositorOutputSurface::SwapBuffers(
+    const cc::LatencyInfo& info) {
+  context3d()->finish();
+  did_swap_buffer_ = true;
+}
+
 void SynchronousCompositorOutputSurface::SetClient(
     SynchronousCompositorClient* compositor_client) {
   DCHECK(CalledOnValidThread());
   compositor_client_ = compositor_client;
+  UpdateCompositorClientSettings();
 }
 
 bool SynchronousCompositorOutputSurface::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();  // TODO(joth): call through to OutputSurfaceClient
   return false;
 }
 
+bool SynchronousCompositorOutputSurface::DemandDrawHw(gfx::Rect damage_rect) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(client_);
+
+  did_swap_buffer_ = false;
+  client_->SetNeedsRedrawRect(damage_rect);
+  if (vsync_enabled_)
+    client_->DidVSync(base::TimeTicks::Now());

[jamesr, 2013/05/07 18:06:41]

can we get an actual frame timestamp from the system?

[boliu, 2013/05/07 19:18:44]

I'm not sure. Also a bit confused about what this value represents. I see the
timestamp is saved as last_tick_time_, and is used along with the interval to
calculate when the next tick should be. So also need to get the real vsync
interval. I'll ask around to see if it is possible.

Interpreting as "last tick time", setting it to now seems completely reasonable.

+
+  return did_swap_buffer_;
+}
+
+void SynchronousCompositorOutputSurface::UpdateCompositorClientSettings() {
+  if (compositor_client_) {
+    compositor_client_->SetContinuousInvalidate(vsync_enabled_);
+  }
+}
+
 // Not using base::NonThreadSafe as we want to enforce a more exacting threading
 // requirement: SynchronousCompositorOutputSurface() must only be used by
 // embedders that supply their own compositor loop via
 // OverrideCompositorMessageLoop().
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return base::MessageLoop::current() && (base::MessageLoop::current() ==
       GetContentClient()->renderer()->OverrideCompositorMessageLoop());
 }
 
 }  // namespace content