Remove duplicated code in AcceleratedSurface using PbufferGLContext instead....

app/surface/accelerated_surface_mac.cc

 // Copyright (c) 2010 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 "app/surface/accelerated_surface_mac.h"
 
 #include "app/gfx/gl/gl_bindings.h"
 #include "app/surface/io_surface_support_mac.h"
 #include "base/logging.h"
 #include "gfx/rect.h"
 
 AcceleratedSurface::AcceleratedSurface()
-    : gl_context_(NULL),
-      pbuffer_(NULL),
-      allocate_fbo_(false),
+    : allocate_fbo_(false),
       texture_(0),
       fbo_(0),
       depth_stencil_renderbuffer_(0) {
 }
 
-bool AcceleratedSurface::Initialize(CGLContextObj share_context,
+bool AcceleratedSurface::Initialize(gfx::GLContext* share_context,
                                     bool allocate_fbo) {
   allocate_fbo_ = allocate_fbo;
 
-  // TODO(kbr): we should reuse the code for PbufferGLContext here instead
-  // of duplicating it. However, in order to do so, we need to move the
-  // GLContext classes out of gpu/ and into gfx/.
+  gl_context_.reset(gfx::GLContext::CreateOffscreenGLContext(share_context));
+  if (!gl_context_.get())
+    return false;
 
-  // Create a 1x1 pbuffer and associated context to bootstrap things
-  static const CGLPixelFormatAttribute attribs[] = {
-    (CGLPixelFormatAttribute) kCGLPFAPBuffer,
-    (CGLPixelFormatAttribute) 0
-  };
-  CGLPixelFormatObj pixel_format;
-  GLint num_pixel_formats;
-  if (CGLChoosePixelFormat(attribs,
-                           &pixel_format,
-                           &num_pixel_formats) != kCGLNoError) {
-    DLOG(ERROR) << "Error choosing pixel format.";
-    return false;
-  }
-  if (!pixel_format) {
-    return false;
-  }
-  CGLContextObj context;
-  CGLError res = CGLCreateContext(pixel_format, share_context, &context);
-  CGLDestroyPixelFormat(pixel_format);
-  if (res != kCGLNoError) {
-    DLOG(ERROR) << "Error creating context.";
-    return false;
-  }
-  CGLPBufferObj pbuffer;
-  if (CGLCreatePBuffer(1, 1,
-                       GL_TEXTURE_2D, GL_RGBA,
-                       0, &pbuffer) != kCGLNoError) {
-    CGLDestroyContext(context);
-    DLOG(ERROR) << "Error creating pbuffer.";
-    return false;
-  }
-  if (CGLSetPBuffer(context, pbuffer, 0, 0, 0) != kCGLNoError) {
-    CGLDestroyContext(context);
-    CGLDestroyPBuffer(pbuffer);
-    DLOG(ERROR) << "Error attaching pbuffer to context.";
-    return false;
-  }
-  gl_context_ = context;
-  pbuffer_ = pbuffer;
-  // Now we're ready to handle SetWindowSize calls, which will
+  // Now we're ready to handle SetSurfaceSize calls, which will
   // allocate and/or reallocate the IOSurface and associated offscreen
   // OpenGL structures for rendering.
   return true;
 }
 
 void AcceleratedSurface::Destroy() {
   // The FBO and texture objects will be destroyed when the OpenGL context,
   // and any other contexts sharing resources with it, is. We don't want to
   // make the context current one last time here just in order to delete
   // these objects.
 
   // Release the old TransportDIB in the browser.
   if (dib_free_callback_.get() && transport_dib_.get()) {
     dib_free_callback_->Run(transport_dib_->id());
   }
   transport_dib_.reset();
-  if (gl_context_)
-    CGLDestroyContext(gl_context_);
-  if (pbuffer_)
-    CGLDestroyPBuffer(pbuffer_);
+
+  if (gl_context_.get())
+    gl_context_->Destroy();
+  gl_context_.reset();
 }
 
 // Call after making changes to the surface which require a visual update.
 // Makes the rendering show up in other processes.
 void AcceleratedSurface::SwapBuffers() {
   if (io_surface_.get() != NULL) {
     if (allocate_fbo_) {
       // Bind and unbind the framebuffer to make changes to the
       // IOSurface show up in the other process.
       glFlush();
@@ skipping 92 matching lines @@
   if (fbo_status == GL_FRAMEBUFFER_COMPLETE_EXT) {
     glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
                                  GL_DEPTH_ATTACHMENT_EXT,
                                  GL_RENDERBUFFER_EXT,
                                  depth_stencil_renderbuffer_);
     fbo_status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
   }
   // Attach the depth and stencil buffer.
   if (fbo_status == GL_FRAMEBUFFER_COMPLETE_EXT) {
     glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
-                                 0x8D20, // GL_STENCIL_ATTACHMENT,
+                                 0x8D20,  // GL_STENCIL_ATTACHMENT,
                                  GL_RENDERBUFFER_EXT,
                                  depth_stencil_renderbuffer_);
     fbo_status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
   }
   return fbo_status == GL_FRAMEBUFFER_COMPLETE_EXT;
 }
 
 bool AcceleratedSurface::MakeCurrent() {
-  if (CGLGetCurrentContext() != gl_context_) {
-    if (CGLSetCurrentContext(gl_context_) != kCGLNoError) {
-      DLOG(ERROR) << "Unable to make gl context current.";
-      return false;
-    }
-  }
-  return true;
+  if (!gl_context_.get())
+    return false;
+  return gl_context_->MakeCurrent();
 }
 
 void AcceleratedSurface::Clear(const gfx::Rect& rect) {
+  DCHECK(gl_context_->IsCurrent());
   glClearColor(0, 0, 0, 0);
   glViewport(0, 0, rect.width(), rect.height());
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0, rect.width(), 0, rect.height(), -1, 1);
   glClear(GL_COLOR_BUFFER_BIT);
 }
 
 uint64 AcceleratedSurface::SetSurfaceSize(const gfx::Size& size) {
   if (surface_size_ == size) {
@@ skipping 37 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(gl_context_,
-                                             target,
-                                             GL_RGBA,
-                                             size.width(),
-                                             size.height(),
-                                             GL_BGRA,
-                                             GL_UNSIGNED_INT_8_8_8_8_REV,
-                                             io_surface_.get(),
-                                             plane);
+  io_surface_support->CGLTexImageIOSurface2D(
+      static_cast<CGLContextObj>(gl_context_->GetHandle()),
+      target,
+      GL_RGBA,
+      size.width(),
+      size.height(),
+      GL_BGRA,
+      GL_UNSIGNED_INT_8_8_8_8_REV,
+      io_surface_.get(),
+      plane);
   if (allocate_fbo_) {
     // Set up the frame buffer object.
     SetupFrameBufferObject(target);
   }
   surface_size_ = size;
 
   // Now send back an identifier for the IOSurface. We originally
   // intended to send back a mach port from IOSurfaceCreateMachPort
   // but it looks like Chrome IPC would need to be modified to
   // properly send mach ports between processes. For the time being we
@@ skipping 30 matching lines @@
     return TransportDIB::DefaultHandleValue();
   }
   transport_dib_.reset(TransportDIB::Map(dib_handle));
   if (transport_dib_.get() == NULL) {
     // TODO(dspringer): if the Map() fails, should the deallocator be run so
     // that the DIB is deallocated in the browser?
     return TransportDIB::DefaultHandleValue();
   }
 
   if (allocate_fbo_) {
+    DCHECK(gl_context_->IsCurrent());
     // Set up the render buffers and reserve enough space on the card for the
     // framebuffer texture.
     GLenum target = GL_TEXTURE_RECTANGLE_ARB;
     AllocateRenderBuffers(target, size);
     glTexImage2D(target,
                  0,  // mipmap level 0
                  GL_RGBA8,  // internal pixel format
                  size.width(),
                  size.height(),
                  0,  // 0 border
                  GL_BGRA,  // Used for consistency
                  GL_UNSIGNED_INT_8_8_8_8_REV,
                  NULL);  // No data, just reserve room on the card.
     SetupFrameBufferObject(target);
   }
   return transport_dib_->handle();
 }
 
 void AcceleratedSurface::SetTransportDIBAllocAndFree(
     Callback2<size_t, TransportDIB::Handle*>::Type* allocator,
     Callback1<TransportDIB::Id>::Type* deallocator) {
   dib_alloc_callback_.reset(allocator);
   dib_free_callback_.reset(deallocator);
 }