Clean up GLSurfaceCGL

content/common/gpu/image_transport_surface_fbo_mac.h

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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.
 
-#ifndef CONTENT_COMMON_GPU_TEXTURE_IMAGE_TRANSPORT_SURFACE_H_
-#define CONTENT_COMMON_GPU_TEXTURE_IMAGE_TRANSPORT_SURFACE_H_
+#ifndef CONTENT_COMMON_GPU_IMAGE_TRANSPORT_SURFACE_FBO_MAC_H_
+#define CONTENT_COMMON_GPU_IMAGE_TRANSPORT_SURFACE_FBO_MAC_H_
 
-#include <string>
-
-#include "base/basictypes.h"
+#include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/image_transport_surface.h"
-#include "gpu/command_buffer/common/mailbox.h"
-#include "gpu/command_buffer/service/texture_manager.h"
-#include "ui/gl/gl_context.h"
-#include "ui/gl/gl_surface.h"
+#include "ui/gl/gl_bindings.h"
 
 namespace content {
-class GpuChannelManager;
 
-class TextureImageTransportSurface
-    : public ImageTransportSurface,
-      public GpuCommandBufferStub::DestructionObserver,
-      public gfx::GLSurface {
+// We are backed by an offscreen surface for the purposes of creating
+// a context, but use FBOs to render to texture. The texture may be backed by
+// an IOSurface, or it may be presented to the screen via a CALayer, depending
+// on the StorageProvider class specified.
+class ImageTransportSurfaceFBO
+    : public gfx::GLSurface,
+      public ImageTransportSurface,
+      public GpuCommandBufferStub::DestructionObserver {
  public:
-  TextureImageTransportSurface(GpuChannelManager* manager,
-                               GpuCommandBufferStub* stub,
-                               const gfx::GLSurfaceHandle& handle);
+  // The interface through which storage for the color buffer of the FBO is
+  // allocated.
+  class StorageProvider {
+   public:
+    virtual ~StorageProvider() {}
+    // IOSurfaces cause too much address space fragmentation if they are
+    // allocated on every resize. This gets a rounded size for allocation.
+    virtual gfx::Size GetRoundedSize(gfx::Size size) = 0;
 
-  // gfx::GLSurface implementation.
+    // Allocate the storage for the color buffer. The specified context is
+    // current, and there is a texture bound to GL_TEXTURE_RECTANGLE_ARB.
+    virtual bool AllocateColorBufferStorage(
+        CGLContextObj context, gfx::Size size) = 0;
+
+    // Free the storage allocated in the AllocateColorBufferStorage call. The
+    // GL texture that was bound has already been deleted by the caller.
+    virtual void FreeColorBufferStorage() = 0;
+
+    // Retrieve the handle for the surface to send to the browser process to
+    // display.

[ccameron, 2014/06/17 19:17:19]

We'll probably need a more substantial interface here when I add the CALayer
stuff (to, at a minimum, distinguish between the two), but this is the minimum
to work with IOSurfaces.

+    virtual uint64 GetSurfaceHandle() const = 0;
+  };
+
+  ImageTransportSurfaceFBO(StorageProvider* storage_provider,
+                           GpuChannelManager* manager,
+                           GpuCommandBufferStub* stub,
+                           gfx::PluginWindowHandle handle);
+
+  // GLSurface implementation
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool DeferDraws() OVERRIDE;
   virtual bool IsOffscreen() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
+  virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
+  virtual bool SupportsPostSubBuffer() OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
   virtual void* GetHandle() OVERRIDE;
-  virtual unsigned GetFormat() OVERRIDE;
-  virtual bool SupportsPostSubBuffer() OVERRIDE;
+  virtual void* GetDisplay() OVERRIDE;
+  virtual bool OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
   virtual unsigned int GetBackingFrameBufferObject() OVERRIDE;
-  virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
   virtual bool SetBackbufferAllocation(bool allocated) OVERRIDE;
   virtual void SetFrontbufferAllocation(bool allocated) OVERRIDE;
-  virtual void* GetShareHandle() OVERRIDE;
-  virtual void* GetDisplay() OVERRIDE;
-  virtual void* GetConfig() OVERRIDE;
 
  protected:
-  // ImageTransportSurface implementation.
+  // ImageTransportSurface implementation
   virtual void OnBufferPresented(
       const AcceleratedSurfaceMsg_BufferPresented_Params& params) OVERRIDE;
   virtual void OnResize(gfx::Size size, float scale_factor) OVERRIDE;
   virtual void SetLatencyInfo(
-      const std::vector<ui::LatencyInfo>& latency_info) OVERRIDE;
+      const std::vector<ui::LatencyInfo>&) OVERRIDE;
   virtual void WakeUpGpu() OVERRIDE;
 
   // GpuCommandBufferStub::DestructionObserver implementation.
   virtual void OnWillDestroyStub() OVERRIDE;
 
  private:
+  virtual ~ImageTransportSurfaceFBO() OVERRIDE;
 
-  gfx::Size backbuffer_size() const {
-    DCHECK(backbuffer_.get());
-    GLsizei width = 0;
-    GLsizei height = 0;
-    backbuffer_->texture()->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height);
-    return gfx::Size(width, height);
-  }
+  void AdjustBufferAllocation();
+  void DestroyFramebuffer();
+  void CreateFramebuffer();
 
-  virtual ~TextureImageTransportSurface();
-  void CreateBackTexture();
-  void AttachBackTextureToFBO();
-  void ReleaseBackTexture();
-  void ReleaseFrontTexture();
-  void BufferPresentedImpl(const gpu::Mailbox& mailbox_name);
+  scoped_ptr<StorageProvider> storage_provider_;
 
-  // The framebuffer that represents this surface (service id). Allocated lazily
-  // in OnMakeCurrent.
-  uint32 fbo_id_;
-
-  // The current backbuffer.
-  scoped_refptr<gpu::gles2::TextureRef> backbuffer_;
-  scoped_refptr<gpu::gles2::TextureRef> frontbuffer_;
-
-  // The mailbox name for the current backbuffer texture. Needs to be unique per
-  // GL texture and is invalid while service_id is zero.
-  gpu::Mailbox back_mailbox_;
-  gpu::Mailbox front_mailbox_;
-
-  // The current size of the GLSurface. Used to disambiguate from the current
-  // texture size which might be outdated (since we use two buffers).
-  gfx::Size current_size_;
-  float scale_factor_;
-
-  // Whether or not the command buffer stub has been destroyed.
-  bool stub_destroyed_;
-
+  // Tracks the current buffer allocation state.
   bool backbuffer_suggested_allocation_;
   bool frontbuffer_suggested_allocation_;
 
-  scoped_ptr<ImageTransportHelper> helper_;
-  gfx::GLSurfaceHandle handle_;
+  uint32 fbo_id_;
+  GLuint texture_id_;
+  GLuint depth_stencil_renderbuffer_id_;
+  bool has_complete_framebuffer_;
 
-  // The offscreen surface used to make the context current. However note that
-  // the actual rendering is always redirected to an FBO.
-  scoped_refptr<gfx::GLSurface> surface_;
+  // Weak pointer to the context that this was last made current to.
+  gfx::GLContext* context_;
+
+  gfx::Size size_;
+  gfx::Size rounded_size_;
+  float scale_factor_;
+
+  // Whether or not we've successfully made the surface current once.
+  bool made_current_;
 
   // Whether a SwapBuffers is pending.
   bool is_swap_buffers_pending_;
 
   // Whether we unscheduled command buffer because of pending SwapBuffers.
   bool did_unschedule_;
 
-  // Holds a reference to the mailbox manager for cleanup.
-  scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
+  std::vector<ui::LatencyInfo> latency_info_;
 
-  std::vector<ui::LatencyInfo> latency_info_;
-  DISALLOW_COPY_AND_ASSIGN(TextureImageTransportSurface);
+  scoped_ptr<ImageTransportHelper> helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageTransportSurfaceFBO);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_COMMON_GPU_TEXTURE_IMAGE_TRANSPORT_SURFACE_H_
+#endif  //  CONTENT_COMMON_GPU_IMAGE_TRANSPORT_SURFACE_MAC_H_