Render Core Animation plugins through WebKit's compositor rather than

ui/gfx/surface/accelerated_surface_mac.cc

 // Copyright (c) 2011 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/gfx/surface/accelerated_surface_mac.h"
 
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_context.h"
@@ skipping 69 matching lines @@
   gl_surface_ = NULL;
 }
 
 // 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();
       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_);
+      glFlush();
     } else {
       // Copy the current framebuffer's contents into our "live" texture.
       // Note that the current GL context might not be ours at this point!
       // This is deliberate, so that surrounding code using GL can produce
       // rendering results consumed by the AcceleratedSurface.
       // Need to save and restore OpenGL state around this call.
       GLint current_texture = 0;
       GLenum target_binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
       GLenum target = GL_TEXTURE_RECTANGLE_ARB;
       glGetIntegerv(target_binding, &current_texture);
@@ skipping 36 matching lines @@
 }
 
 static void AddIntegerValue(CFMutableDictionaryRef dictionary,
                             const CFStringRef key,
                             int32 value) {
   base::mac::ScopedCFTypeRef<CFNumberRef> number(
       CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
   CFDictionaryAddValue(dictionary, key, number.get());
 }
 
+// Creates a new OpenGL texture object bound to the given texture target.
+// Caller owns the returned texture.
+static GLuint CreateTexture(GLenum target) {
+  GLuint texture = 0;
+  glGenTextures(1, &texture);
+  glBindTexture(target, texture);
+  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);
+  return texture;
+}
+
 void AcceleratedSurface::AllocateRenderBuffers(GLenum target,
                                                const gfx::Size& size) {
   if (!texture_) {
     // Generate the texture object.
-    glGenTextures(1, &texture_);
-    glBindTexture(target, texture_);
-    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);
+    texture_ = CreateTexture(target);
     // Generate and bind the framebuffer object.
     glGenFramebuffersEXT(1, &fbo_);
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_);
     // Generate (but don't bind) the depth buffer -- we don't need
     // this bound in order to do offscreen rendering.
     glGenRenderbuffersEXT(1, &depth_stencil_renderbuffer_);
   }
 
   // Reallocate the depth buffer.
   glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_stencil_renderbuffer_);
@@ skipping 49 matching lines @@
 void AcceleratedSurface::Clear(const gfx::Rect& rect) {
   DCHECK(gl_context_->IsCurrent(gl_surface_.get()));
   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) {
+uint32 AcceleratedSurface::SetSurfaceSize(const gfx::Size& size) {
   if (surface_size_ == size) {
     // Return 0 to indicate to the caller that no new backing store
     // 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;  // Caller can try using SetWindowSizeForTransportDIB().
 
   gfx::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.
-    glGenTextures(1, &texture_);
-    glBindTexture(target, texture_);
-    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);
+    texture_ = CreateTexture(target);
   }
 
   // Allocate a new IOSurface, which is the GPU resource that can be
   // shared across processes.
   base::mac::ScopedCFTypeRef<CFMutableDictionaryRef> properties;
   properties.reset(CFDictionaryCreateMutable(kCFAllocatorDefault,
                                              0,
                                              &kCFTypeDictionaryKeyCallBacks,
                                              &kCFTypeDictionaryValueCallBacks));
   AddIntegerValue(properties,
@@ skipping 34 matching lines @@
   // 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_);
   return io_surface_id_;
 }
 
-uint64 AcceleratedSurface::GetSurfaceId() {
+uint32 AcceleratedSurface::GetSurfaceId() {
   return io_surface_id_;
 }
 
 TransportDIB::Handle AcceleratedSurface::SetTransportDIBSize(
     const gfx::Size& size) {
   if (surface_size_ == size) {
     // Return an invalid handle to indicate to the caller that no new backing
     // store allocation occurred.
     return TransportDIB::DefaultHandleValue();
   }
@@ skipping 45 matching lines @@
   }
   return transport_dib_->handle();
 }
 
 void AcceleratedSurface::SetTransportDIBAllocAndFree(
     const base::Callback<void(size_t, TransportDIB::Handle*)>& allocator,
     const base::Callback<void(TransportDIB::Id)>& deallocator) {
   dib_alloc_callback_ = allocator;
   dib_free_callback_ = deallocator;
 }