Delete background tab IOSurfaces on Mac.

content/common/gpu/image_transport_surface_mac.cc

 // Copyright (c) 2012 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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/common/gpu/image_transport_surface.h"
 
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 19 matching lines @@
   // GLSurface implementation
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool IsOffscreen() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
   virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
   virtual std::string GetExtensions() OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
   virtual unsigned int GetBackingFrameBufferObject() OVERRIDE;
+  virtual void SetBufferAllocation(BufferAllocationState state) OVERRIDE;
 
  protected:
   // ImageTransportSurface implementation
   virtual void OnNewSurfaceACK(uint64 surface_handle,
                                TransportDIB::Handle shm_handle) OVERRIDE;
   virtual void OnBuffersSwappedACK() OVERRIDE;
   virtual void OnPostSubBufferACK() OVERRIDE;
   virtual void OnResizeViewACK() OVERRIDE;
   virtual void OnResize(gfx::Size size) OVERRIDE;
 
  private:
   virtual ~IOSurfaceImageTransportSurface() OVERRIDE;
 
+  void UnrefIOSurface();
+  void CreateIOSurface();
+
+  BufferAllocationState buffer_allocation_state_;
+
   uint32 fbo_id_;
   GLuint texture_id_;
 
   base::mac::ScopedCFTypeRef<CFTypeRef> io_surface_;
 
   // The id of |io_surface_| or 0 if that's NULL.
   uint64 io_surface_handle_;
 
   // Weak pointer to the context that this was last made current to.
   gfx::GLContext* context_;
@@ skipping 21 matching lines @@
   base::mac::ScopedCFTypeRef<CFNumberRef> number(
       CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
   CFDictionaryAddValue(dictionary, key, number.get());
 }
 
 IOSurfaceImageTransportSurface::IOSurfaceImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gfx::PluginWindowHandle handle)
     : gfx::NoOpGLSurfaceCGL(gfx::Size(1, 1)),
+      buffer_allocation_state_(BUFFER_ALLOCATION_FRONT_AND_BACK),
       fbo_id_(0),
       texture_id_(0),
       io_surface_handle_(0),
       context_(NULL),
       made_current_(false) {
   helper_.reset(new ImageTransportHelper(this, manager, stub, handle));
 }
 
 IOSurfaceImageTransportSurface::~IOSurfaceImageTransportSurface() {
   Destroy();
@@ skipping 30 matching lines @@
 bool IOSurfaceImageTransportSurface::IsOffscreen() {
   return false;
 }
 
 bool IOSurfaceImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   context_ = context;
 
   if (made_current_)
     return true;
 
-  glGenFramebuffersEXT(1, &fbo_id_);
-  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id_);
   OnResize(gfx::Size(1, 1));
 
-  GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
-  if (status != GL_FRAMEBUFFER_COMPLETE) {
-    DLOG(ERROR) << "Framebuffer incomplete.";
-    return false;
-  }
-
   made_current_ = true;
   return true;
 }
 
 unsigned int IOSurfaceImageTransportSurface::GetBackingFrameBufferObject() {
   return fbo_id_;
 }
 
+void IOSurfaceImageTransportSurface::SetBufferAllocation(
+    BufferAllocationState state) {
+  if (buffer_allocation_state_ == state)
+    return;
+  buffer_allocation_state_ = state;
+
+  switch (state) {
+    case BUFFER_ALLOCATION_FRONT_AND_BACK:
+      CreateIOSurface();
+      break;
+
+    case BUFFER_ALLOCATION_FRONT_ONLY:
+      break;
+
+    case BUFFER_ALLOCATION_NONE:
+      UnrefIOSurface();
+      helper_->Suspend();
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
 bool IOSurfaceImageTransportSurface::SwapBuffers() {
   glFlush();
 
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.surface_handle = io_surface_handle_;
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
 
   helper_->SetScheduled(false);
   return true;
 }
@@ skipping 38 matching lines @@
     uint64 surface_handle,
     TransportDIB::Handle /* shm_handle */) {
   NOTREACHED();
 }
 
 void IOSurfaceImageTransportSurface::OnResizeViewACK() {
   NOTREACHED();
 }
 
 void IOSurfaceImageTransportSurface::OnResize(gfx::Size size) {
-  IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
-
   // Caching |context_| from OnMakeCurrent. It should still be current.
   DCHECK(context_->IsCurrent(this));
 
   size_ = size;
 
+  CreateIOSurface();
+}
+
+void IOSurfaceImageTransportSurface::UnrefIOSurface() {
+  if (fbo_id_) {
+    GLenum target = GL_TEXTURE_RECTANGLE_ARB;
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,

[Ken Russell (switch to Gerrit), 2012/04/18 02:00:27]

How about a DCHECK that the context is current, as in OnResize(), to make sure
that OnMakeCurrent has been called and that fbo_id_ is bound to
GL_FRAMEBUFFER_EXT?

Also, as we've discussed, this detaching shouldn't be necessary, since the FBO's
about to be deleted.

[jbates, 2012/04/18 23:01:58]

Done.

+                              GL_COLOR_ATTACHMENT0_EXT,
+                              target,
+                              0,
+                              0);
+
+    glDeleteFramebuffersEXT(1, &fbo_id_);
+
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+    fbo_id_ = 0;
+  }
+
   if (texture_id_) {
     glDeleteTextures(1, &texture_id_);
     texture_id_ = 0;
   }
 
-  glGenTextures(1, &texture_id_);
+  io_surface_.reset();
 
+  io_surface_handle_ = 0;
+}
+
+void IOSurfaceImageTransportSurface::CreateIOSurface() {
   GLint previous_texture_id = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &previous_texture_id);
 
+  UnrefIOSurface();
+
+  glGenFramebuffersEXT(1, &fbo_id_);
+  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id_);
+
+  IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
+
+  glGenTextures(1, &texture_id_);
+
   // GL_TEXTURE_RECTANGLE_ARB is the best supported render target on
   // Mac OS X and is required for IOSurface interoperability.
   GLenum target = GL_TEXTURE_RECTANGLE_ARB;
   glBindTexture(target, texture_id_);
   glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-  GLint previous_fbo_id = 0;
-  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &previous_fbo_id);
-
-  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id_);
-
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
                             GL_COLOR_ATTACHMENT0_EXT,
                             target,
                             texture_id_,
                             0);
 
   // Allocate a new IOSurface, which is the GPU resource that can be
   // shared across processes.
   base::mac::ScopedCFTypeRef<CFMutableDictionaryRef> properties;
   properties.reset(CFDictionaryCreateMutable(kCFAllocatorDefault,
@@ skipping 10 matching lines @@
                   io_surface_support->GetKIOSurfaceBytesPerElement(), 4);
   AddBooleanValue(properties,
                   io_surface_support->GetKIOSurfaceIsGlobal(), true);
   // I believe we should be able to unreference the IOSurfaces without
   // synchronizing with the browser process because they are
   // ultimately reference counted by the operating system.
   io_surface_.reset(io_surface_support->IOSurfaceCreate(properties));
 
   // Don't think we need to identify a plane.
   GLuint plane = 0;
-  io_surface_support->CGLTexImageIOSurface2D(
-      static_cast<CGLContextObj>(context_->GetHandle()),
-      target,
-      GL_RGBA,
-      size_.width(),
-      size_.height(),
-      GL_BGRA,
-      GL_UNSIGNED_INT_8_8_8_8_REV,
-      io_surface_.get(),
-      plane);
+  CGLError cglerror =
+      io_surface_support->CGLTexImageIOSurface2D(
+          static_cast<CGLContextObj>(context_->GetHandle()),
+          target,
+          GL_RGBA,
+          size_.width(),
+          size_.height(),
+          GL_BGRA,
+          GL_UNSIGNED_INT_8_8_8_8_REV,
+          io_surface_.get(),
+          plane);
+  if (cglerror != kCGLNoError) {
+    DLOG(ERROR) << "CGLTexImageIOSurface2D: " << cglerror;
+    UnrefIOSurface();
+    return;
+  }
 
   io_surface_handle_ = io_surface_support->IOSurfaceGetID(io_surface_);
   glFlush();
 
   glBindTexture(target, previous_texture_id);
-  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, previous_fbo_id);
+  // The FBO remains bound for this GL context.

[Ken Russell (switch to Gerrit), 2012/04/18 02:00:27]

Please document in the header that OnResize changes the currently bound FBO.

[jbates, 2012/04/18 23:01:58]

Done.

 }
 
 }  // namespace
 
 // static
 scoped_refptr<gfx::GLSurface> ImageTransportSurface::CreateSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     const gfx::GLSurfaceHandle& surface_handle) {
   scoped_refptr<gfx::GLSurface> surface;
@@ skipping 14 matching lines @@
       NOTREACHED();
       return NULL;
   }
   if (surface->Initialize())
     return surface;
   else
     return NULL;
 }
 
 #endif  // defined(USE_GPU)