Surfaceless OutputSurface implementation.

content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.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 "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
+
+#include "cc/output/compositor_frame.h"
+#include "content/browser/compositor/buffered_output_surface.h"
+#include "content/browser/compositor/reflector_impl.h"
+#include "content/browser/gpu/gpu_surface_tracker.h"
+#include "content/common/gpu/client/context_provider_command_buffer.h"
+#include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+
+namespace content {
+
+GpuSurfacelessBrowserCompositorOutputSurface::
+    GpuSurfacelessBrowserCompositorOutputSurface(
+        const scoped_refptr<ContextProviderCommandBuffer>& context,
+        int surface_id,
+        IDMap<BrowserCompositorOutputSurface>* output_surface_map,
+        const scoped_refptr<ui::CompositorVSyncManager>& vsync_manager,
+        scoped_ptr<cc::OverlayCandidateValidator> overlay_candidate_validator,
+        unsigned internalformat,
+        int z_order)
+    : GpuBrowserCompositorOutputSurface(context,
+                                        surface_id,
+                                        output_surface_map,
+                                        vsync_manager,
+                                        overlay_candidate_validator.Pass()),
+      z_order_(z_order),
+      expects_pageflip_messages_(false),
+      internalformat_(internalformat) {
+}
+
+GpuSurfacelessBrowserCompositorOutputSurface::
+    ~GpuSurfacelessBrowserCompositorOutputSurface() {
+}
+
+void GpuSurfacelessBrowserCompositorOutputSurface::SwapBuffers(
+    cc::CompositorFrame* frame) {
+  DCHECK(output_surface_);
+  output_surface_->SwapBuffers();
+
+  const gfx::Size& size = frame->gl_frame_data->size;
+  gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
+  gl->Finish();
+  gl->ScheduleOverlayPlaneCHROMIUM(z_order_,
+                                   GL_OVERLAY_TRANSFORM_NONE_CHROMIUM,
+                                   output_surface_->tex_id(),
+                                   0,
+                                   0,
+                                   size.width(),
+                                   size.height(),
+                                   0,
+                                   0,
+                                   1.0f,
+                                   1.0f);
+  GpuBrowserCompositorOutputSurface::SwapBuffers(frame);
+}
+
+void GpuSurfacelessBrowserCompositorOutputSurface::OnSwapBuffersComplete() {
+  DCHECK(output_surface_);
+  // PageFlipComplete must be called to properly drive the buffering. If we
+  // don't expect to receive these calls from IPCs, we should call it here.
+  if (!expects_pageflip_messages_)

[alexst (slow to review), 2014/09/10 17:37:09]

Page flip message is what should trigger the OnSwapBuffersComplete, so I don't
think we need this variable.

We should modify
https://code.google.com/p/chromium/codesearch#chromium/src/gpu/command_buffer...

to understand surfaceless and not just send an echo, but to send an actual swap
complete message.

[achaulk, 2014/09/10 18:56:07]

Done.

+    output_surface_->PageFlipComplete();
+  GpuBrowserCompositorOutputSurface::OnSwapBuffersComplete();
+}
+
+void GpuSurfacelessBrowserCompositorOutputSurface::BindFramebuffer() {
+  DCHECK(output_surface_);
+  output_surface_->BindFramebuffer();
+}
+
+void GpuSurfacelessBrowserCompositorOutputSurface::Reshape(
+    const gfx::Size& size,
+    float scale_factor) {
+  gfx::Size current = SurfaceSize();
+  GpuBrowserCompositorOutputSurface::Reshape(size, scale_factor);
+  DCHECK(output_surface_);
+  output_surface_->Reshape(SurfaceSize(), scale_factor);
+}
+
+bool GpuSurfacelessBrowserCompositorOutputSurface::BindToClient(
+    cc::OutputSurfaceClient* client) {
+  DCHECK(output_surface_);
+  if (!GpuBrowserCompositorOutputSurface::BindToClient(client))
+    return false;
+  if (!output_surface_) {
+    output_surface_.reset(
+        new BufferedOutputSurface(context_provider_, internalformat_));
+  }
+  return true;
+}
+
+}  // namespace content