Remove IOSurfaceSupport

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.
 
 #include "content/common/gpu/image_transport_surface.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/gpu_messages.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_cgl.h"
 #include "ui/gl/gl_surface_osmesa.h"
-#include "ui/gl/io_surface_support_mac.h"
+
+// Note that this must be included after gl_bindings.h to avoid conflicts.
+#include <OpenGL/CGLIOSurface.h>
 
 namespace content {
 namespace {
 
 // IOSurface dimensions will be rounded up to a multiple of this value in order
 // to reduce memory thrashing during resize. This must be a power of 2.
 const uint32 kIOSurfaceDimensionRoundup = 64;
 
 int RoundUpSurfaceDimension(int number) {
   DCHECK(number >= 0);
@@ skipping 49 matching lines @@
   void CreateIOSurface();
 
   // Tracks the current buffer allocation state.
   bool backbuffer_suggested_allocation_;
   bool frontbuffer_suggested_allocation_;
 
   uint32 fbo_id_;
   GLuint texture_id_;
   GLuint depth_stencil_renderbuffer_id_;
 
-  base::ScopedCFTypeRef<CFTypeRef> io_surface_;
+  base::ScopedCFTypeRef<IOSurfaceRef> 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_;
 
   gfx::Size size_;
   gfx::Size rounded_size_;
   float scale_factor_;
@@ skipping 278 matching lines @@
 
   GLint previous_texture_id = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &previous_texture_id);
 
   // Free the old IO Surface first to reduce memory fragmentation.
   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);
@@ skipping 36 matching lines @@
   }
 
   // Allocate a new IOSurface, which is the GPU resource that can be
   // shared across processes.
   base::ScopedCFTypeRef<CFMutableDictionaryRef> properties;
   properties.reset(CFDictionaryCreateMutable(kCFAllocatorDefault,
                                              0,
                                              &kCFTypeDictionaryKeyCallBacks,
                                              &kCFTypeDictionaryValueCallBacks));
   AddIntegerValue(properties,
-                  io_surface_support->GetKIOSurfaceWidth(),
+                  kIOSurfaceWidth,
                   rounded_size_.width());
   AddIntegerValue(properties,
-                  io_surface_support->GetKIOSurfaceHeight(),
+                  kIOSurfaceHeight,
                   rounded_size_.height());
   AddIntegerValue(properties,
-                  io_surface_support->GetKIOSurfaceBytesPerElement(), 4);
+                  kIOSurfaceBytesPerElement, 4);
   AddBooleanValue(properties,
-                  io_surface_support->GetKIOSurfaceIsGlobal(), true);
+                  kIOSurfaceIsGlobal, 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));
-  io_surface_handle_ = io_surface_support->IOSurfaceGetID(io_surface_);
+  io_surface_.reset(IOSurfaceCreate(properties));
+  io_surface_handle_ = IOSurfaceGetID(io_surface_);
 
   // Don't think we need to identify a plane.
   GLuint plane = 0;
   CGLError cglerror =
-      io_surface_support->CGLTexImageIOSurface2D(
+      CGLTexImageIOSurface2D(
           static_cast<CGLContextObj>(context_->GetHandle()),
           target,
           GL_RGBA,
           rounded_size_.width(),
           rounded_size_.height(),
           GL_BGRA,
           GL_UNSIGNED_INT_8_8_8_8_REV,
           io_surface_.get(),
           plane);
   if (cglerror != kCGLNoError) {
@@ skipping 37 matching lines @@
 
 }  // namespace
 
 // static
 scoped_refptr<gfx::GLSurface> ImageTransportSurface::CreateNativeSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     const gfx::GLSurfaceHandle& surface_handle) {
   DCHECK(surface_handle.transport_type == gfx::NATIVE_DIRECT ||
          surface_handle.transport_type == gfx::NATIVE_TRANSPORT);
-  IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
 
   switch (gfx::GetGLImplementation()) {
     case gfx::kGLImplementationDesktopGL:
     case gfx::kGLImplementationAppleGL:
-      if (!io_surface_support) {
-        DLOG(WARNING) << "No IOSurface support";
-        return scoped_refptr<gfx::GLSurface>();
-      }
       return scoped_refptr<gfx::GLSurface>(new IOSurfaceImageTransportSurface(
           manager, stub, surface_handle.handle));
 
     default:
       // Content shell in DRT mode spins up a gpu process which needs an
       // image transport surface, but that surface isn't used to read pixel
       // baselines. So this is mostly a dummy surface.
       if (!g_allow_os_mesa) {
         NOTREACHED();
         return scoped_refptr<gfx::GLSurface>();
       }
       scoped_refptr<gfx::GLSurface> surface(new DRTSurfaceOSMesa());
       if (!surface.get() || !surface->Initialize())
         return surface;
       return scoped_refptr<gfx::GLSurface>(new PassThroughImageTransportSurface(
           manager, stub, surface.get()));
   }
 }
 
 // static
 void ImageTransportSurface::SetAllowOSMesaForTesting(bool allow) {
   g_allow_os_mesa = allow;
 }
 
 }  // namespace content