Remove IOSurfaceSupport

ui/surface/accelerated_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 "ui/surface/accelerated_surface_mac.h"
 
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "ui/gfx/rect.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
-#include "ui/gl/io_surface_support_mac.h"
 #include "ui/gl/scoped_make_current.h"
 
+// Note that this must be included after gl_bindings.h to avoid conflicts.
+#include <OpenGL/CGLIOSurface.h>
+
 AcceleratedSurface::AcceleratedSurface()
     : io_surface_id_(0),
       allocate_fbo_(false),
       texture_(0),
       fbo_(0) {
 }
 
 AcceleratedSurface::~AcceleratedSurface() {}
 
 bool AcceleratedSurface::Initialize(
@@ skipping 158 matching lines @@
     // allocation occurred.
     return 0;
   }
 
   // Only support IO surfaces if the GL implementation is the native desktop GL.
   // IO surfaces will not work with, for example, OSMesa software renderer
   // GL contexts.
   if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL)
     return 0;
 
-  IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
-  if (!io_surface_support)
-    return 0;
-
   ui::ScopedMakeCurrent make_current(gl_context_.get(), gl_surface_.get());
   if (!make_current.Succeeded())
     return 0;
 
   gfx::Size clamped_size = ClampToValidDimensions(size);
 
   // 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;
   if (allocate_fbo_) {
     AllocateRenderBuffers(target, clamped_size);
   } else if (!texture_) {
     // Generate the texture object.
     texture_ = CreateTexture(target);
   }
 
   // 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(),
-                  clamped_size.width());
-  AddIntegerValue(properties,
-                  io_surface_support->GetKIOSurfaceHeight(),
-                  clamped_size.height());
-  AddIntegerValue(properties,
-                  io_surface_support->GetKIOSurfaceBytesPerElement(), 4);
-  AddBooleanValue(properties,
-                  io_surface_support->GetKIOSurfaceIsGlobal(), true);
+  AddIntegerValue(properties, kIOSurfaceWidth, clamped_size.width());
+  AddIntegerValue(properties, kIOSurfaceHeight, clamped_size.height());
+  AddIntegerValue(properties, kIOSurfaceBytesPerElement, 4);
+  AddBooleanValue(properties, 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_.reset(IOSurfaceCreate(properties));
 
   // Don't think we need to identify a plane.
   GLuint plane = 0;
-  CGLError error = io_surface_support->CGLTexImageIOSurface2D(
+  CGLError error = CGLTexImageIOSurface2D(
       static_cast<CGLContextObj>(gl_context_->GetHandle()),
       target,
       GL_RGBA,
       clamped_size.width(),
       clamped_size.height(),
       GL_BGRA,
       GL_UNSIGNED_INT_8_8_8_8_REV,
       io_surface_.get(),
       plane);
   if (error != kCGLNoError) {
     DLOG(ERROR) << "CGL error " << error << " during CGLTexImageIOSurface2D";
   }
   if (allocate_fbo_) {
     // Set up the frame buffer object.
     if (!SetupFrameBufferObject(target)) {
       DLOG(ERROR) << "Failed to set up frame buffer object";
     }
   }
   surface_size_ = size;
   real_surface_size_ = clamped_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
   // make our IOSurfaces global and send back their identifiers. On
   // the browser process side the identifier is reconstituted into an
   // IOSurface for on-screen rendering.
-  io_surface_id_ = io_surface_support->IOSurfaceGetID(io_surface_);
+  io_surface_id_ = IOSurfaceGetID(io_surface_);
   return io_surface_id_;
 }
 
 uint32 AcceleratedSurface::GetSurfaceId() {
   return io_surface_id_;
 }