gpu: reference target surfaces through a globally unique surface id.

content/browser/renderer_host/image_transport_client.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 "content/browser/renderer_host/image_transport_client.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xcomposite.h>
 
 #include "base/debug/trace_event.h"
@@ skipping 37 matching lines @@
 
   virtual ~ImageTransportClientEGL() {
     if (image_) {
       scoped_ptr<gfx::ScopedMakeCurrent> bind(
           resources_->GetScopedMakeCurrent());
       eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), image_);
       glFlush();
     }
   }
 
-  virtual unsigned int Initialize(uint64* surface_id) {
+  virtual unsigned int Initialize(uint64* surface_handle) {
     scoped_ptr<gfx::ScopedMakeCurrent> bind(resources_->GetScopedMakeCurrent());
     image_ = eglCreateImageKHR(
         gfx::GLSurfaceEGL::GetHardwareDisplay(), EGL_NO_CONTEXT,
-        EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<void*>(*surface_id), NULL);
+        EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<void*>(*surface_handle), NULL);
     if (!image_)
       return 0;
     GLuint texture = CreateTexture();
     glBindTexture(GL_TEXTURE_2D, texture);
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image_);
     glFlush();
     return texture;
   }
 
   virtual void Acquire() { }
@@ skipping 20 matching lines @@
   }
 
   virtual ~ImageTransportClientGLX() {
     Display* dpy = static_cast<Display*>(resources_->GetDisplay());
     if (glx_pixmap_)
       glXDestroyGLXPixmap(dpy, glx_pixmap_);
     if (pixmap_)
       XFreePixmap(dpy, pixmap_);
   }
 
-  virtual unsigned int Initialize(uint64* surface_id) {
+  virtual unsigned int Initialize(uint64* surface_handle) {
     TRACE_EVENT0("renderer_host", "ImageTransportClientGLX::Initialize");
     Display* dpy = static_cast<Display*>(resources_->GetDisplay());
 
     scoped_ptr<gfx::ScopedMakeCurrent> bind(resources_->GetScopedMakeCurrent());
     if (!InitializeOneOff(dpy))
         return 0;
 
     // Create pixmap from window.
     // We receive a window here rather than a pixmap directly because drivers
     // require (or required) that the pixmap used to create the GL texture be
     // created in the same process as the texture.
-    pixmap_ = XCompositeNameWindowPixmap(dpy, *surface_id);
+    pixmap_ = XCompositeNameWindowPixmap(dpy, *surface_handle);
 
     const int pixmapAttribs[] = {
       GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
       GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
       0
     };
 
     glx_pixmap_ = glXCreatePixmap(dpy, fbconfig_.Get(), pixmap_, pixmapAttribs);
 
     texture_ = CreateTexture();
@@ skipping 100 matching lines @@
   ImageTransportClientOSMesa(ui::SharedResources* resources,
                              const gfx::Size& size)
       : resources_(resources),
         size_(size),
         texture_(0) {
   }
 
   virtual ~ImageTransportClientOSMesa() {
   }
 
-  virtual unsigned int Initialize(uint64* surface_id) {
-    // We expect to make the id here, so don't want the other end giving us one
-    DCHECK_EQ(*surface_id, static_cast<uint64>(0));
+  virtual unsigned int Initialize(uint64* surface_handle) {
+    // We expect to make the handle here, so don't want the other end giving us
+    // one.
+    DCHECK_EQ(*surface_handle, static_cast<uint64>(0));
 
     // It's possible that this ID gneration could clash with IDs from other
     // AcceleratedSurfaceContainerTouch* objects, however we should never have
     // ids active from more than one type at the same time, so we have free
     // reign of the id namespace.
-    *surface_id = next_id_++;
+    *surface_handle = next_handle_++;
 
     shared_mem_.reset(
         TransportDIB::Create(size_.GetArea() * 4,  // GL_RGBA=4 B/px
-        *surface_id));
+        *surface_handle));
     if (!shared_mem_.get())
       return 0;
 
     scoped_ptr<gfx::ScopedMakeCurrent> bind(resources_->GetScopedMakeCurrent());
     texture_ = CreateTexture();
     return texture_;
   }
 
   virtual void Acquire() {
     glBindTexture(GL_TEXTURE_2D, texture_);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
                  size_.width(), size_.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, shared_mem_->memory());
   }
 
   virtual void Release() { }
   virtual bool Flipped() { return false; }
   virtual TransportDIB::Handle Handle() const { return shared_mem_->handle(); }
 
  private:
   ui::SharedResources* resources_;
   gfx::Size size_;
   scoped_ptr<TransportDIB> shared_mem_;
   GLuint texture_;
-  static uint32 next_id_;
+  static uint32 next_handle_;
 };
-uint32 ImageTransportClientOSMesa::next_id_ = 0;
+uint32 ImageTransportClientOSMesa::next_handle_ = 0;
 
 #endif //  !USE_WAYLAND
 
 }  // anonymous namespace
 
 ImageTransportClient* ImageTransportClient::Create(
     ui::SharedResources* resources,
     const gfx::Size& size) {
   switch (gfx::GetGLImplementation()) {
 #if !defined(USE_WAYLAND)
     case gfx::kGLImplementationOSMesaGL:
       return new ImageTransportClientOSMesa(resources, size);
     case gfx::kGLImplementationDesktopGL:
       return new ImageTransportClientGLX(resources);
 #endif
     case gfx::kGLImplementationEGLGLES2:
       return new ImageTransportClientEGL(resources);
     default:
       NOTREACHED();
       return NULL;
   }
 }