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): RenderWidgetImpl should create in process contexts as well.

[joth, 2013/05/03 01:26:26]

should it?

[boliu, 2013/05/03 05:25:50]

Oops, should have said RenderThreadImpl, which creates the offscreen context.
Should discuss with James if this function should even be here. Maybe both
should be handled directly in render_widget/thread.

+scoped_ptr<WebKit::WebGraphicsContext3D> CreateWebGraphicsContext3D() {
+  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.
 }
 
 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();
+}
+
 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;
 }
 
+void SynchronousCompositorOutputSurface::DemandDrawHw(gfx::Rect damage_rect) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(client_);
+
+  client_->SetNeedsRedrawRect(damage_rect);
+  if (vsync_enabled_)
+    client_->DidVSync(base::TimeTicks::Now());
+
+  // This is used to make sure that the GLContextVirtual used by the compositor
+  // restores its state.
+  static scoped_ptr<WebKit::WebGraphicsContext3D> background_context =
+      CreateWebGraphicsContext3D();
+  background_context->makeContextCurrent();
+}
+
+void SynchronousCompositorOutputSurface::UpdateCompositorClientSettings() {
+  if (compositor_client_) {
+    compositor_client_->SetContinuousInvalidate(vsync_enabled_);

[joth, 2013/05/03 01:26:26]

makes me sad that the 'vsync_enabled_ state is duplicated in this class and in
the client (view renderer), but nothing cleaner springs to mind. (except maybe
just having SyncCompClient::Invalidate()  -- no params -- and keep all the logic
in here to drive it)

+  }
+}
+
 // 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