EGL contexts reference count the EGL surfaces they share....

app/gfx/gl/gl_context_egl.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 <EGL/egl.h>
 
 #include "build/build_config.h"
 #if defined(OS_LINUX)
 #include "app/x11_util.h"
 #define EGL_HAS_PBUFFERS 1
@@ skipping 40 matching lines @@
     case EGL_BAD_NATIVE_PIXMAP:
       return "EGL_BAD_NATIVE_PIXMAP";
     case EGL_BAD_NATIVE_WINDOW:
       return "EGL_BAD_NATIVE_WINDOW";
     default:
       return "UNKNOWN";
   }
 }
 }  // namespace anonymous
 
+SharedEGLSurface::SharedEGLSurface(EGLSurface surface) : surface_(surface) {
+}
+
+SharedEGLSurface::~SharedEGLSurface() {
+  if (surface_) {
+    if (!eglDestroySurface(g_display, surface_)) {
+      LOG(ERROR) << "eglDestroySurface failed with error "
+                 << GetLastEGLErrorString();
+    }
+  }
+}
+
+EGLSurface SharedEGLSurface::egl_surface() const {
+  return surface_;
+}
+
 bool BaseEGLContext::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
 #ifdef OS_LINUX
   EGLNativeDisplayType native_display = x11_util::GetXDisplay();
 #else
   EGLNativeDisplayType native_display = EGL_DEFAULT_DISPLAY;
 #endif
@@ skipping 65 matching lines @@
 std::string BaseEGLContext::GetExtensions() {
   const char* extensions = eglQueryString(g_display, EGL_EXTENSIONS);
   if (!extensions)
     return GLContext::GetExtensions();
 
   return GLContext::GetExtensions() + " " + extensions;
 }
 
 NativeViewEGLContext::NativeViewEGLContext(void* window)
     : window_(window),
-      surface_(NULL),
       context_(NULL)
 {
 }
 
 NativeViewEGLContext::~NativeViewEGLContext() {
 }
 
 bool NativeViewEGLContext::Initialize() {
   DCHECK(!context_);
 
   // Create a surface for the native window.
   EGLNativeWindowType native_window =
       reinterpret_cast<EGLNativeWindowType>(window_);
-  surface_ = eglCreateWindowSurface(g_display, g_config, native_window, NULL);
+  surface_ = new SharedEGLSurface(eglCreateWindowSurface(g_display,
+                                                         g_config,
+                                                         native_window,
+                                                         NULL));
 
-  if (!surface_) {
+  if (!surface_->egl_surface()) {
     LOG(ERROR) << "eglCreateWindowSurface failed with error "
                << GetLastEGLErrorString();
     Destroy();
     return false;
   }
 
   static const EGLint kContextAttributes[] = {
     EGL_CONTEXT_CLIENT_VERSION, 2,
     EGL_NONE
   };
@@ skipping 24 matching lines @@
 void NativeViewEGLContext::Destroy() {
   if (context_) {
     if (!eglDestroyContext(g_display, context_)) {
       LOG(ERROR) << "eglDestroyContext failed with error "
                  << GetLastEGLErrorString();
     }
 
     context_ = NULL;
   }
 
-  if (surface_) {
-    if (!eglDestroySurface(g_display, surface_)) {
-      LOG(ERROR) << "eglDestroySurface failed with error "
-                 << GetLastEGLErrorString();
-    }
-
-    surface_ = NULL;
-  }
+  surface_ = NULL;
 }
 
 bool NativeViewEGLContext::MakeCurrent() {
   DCHECK(context_);
   if (!eglMakeCurrent(g_display,
-                      surface_, surface_,
+                      surface_->egl_surface(),
+                      surface_->egl_surface(),
                       context_)) {
     VLOG(1) << "eglMakeCurrent failed with error "
             << GetLastEGLErrorString();
     return false;
   }
 
   return true;
 }
 
 bool NativeViewEGLContext::IsCurrent() {
   DCHECK(context_);
   return context_ == eglGetCurrentContext();
 }
 
 bool NativeViewEGLContext::IsOffscreen() {
   return false;
 }
 
 bool NativeViewEGLContext::SwapBuffers() {
-  if (!eglSwapBuffers(g_display, surface_)) {
+  if (!eglSwapBuffers(g_display, surface_->egl_surface())) {
     VLOG(1) << "eglSwapBuffers failed with error "
             << GetLastEGLErrorString();
     return false;
   }
 
   return true;
 }
 
 gfx::Size NativeViewEGLContext::GetSize() {
 #if defined(OS_WIN)
   RECT rect;
   if (!GetClientRect(static_cast<HWND>(window_), &rect)) {
     DCHECK(false) << "GetClientRect failed.";
     return gfx::Size();
   }
 
   return gfx::Size(rect.right - rect.left, rect.bottom - rect.top);
 #else
   // TODO(piman): This doesn't work correctly on Windows yet, the size doesn't
   // get updated on resize. When it does, we can share the code.
   EGLint width;
   EGLint height;
-  if (!eglQuerySurface(g_display, surface_, EGL_WIDTH, &width) ||
-      !eglQuerySurface(g_display, surface_, EGL_HEIGHT, &height)) {
+  if (!eglQuerySurface(
+          g_display, surface_->egl_surface(), EGL_WIDTH, &width) ||
+      !eglQuerySurface(
+          g_display, surface_->egl_surface(), EGL_HEIGHT, &height)) {
     NOTREACHED() << "eglQuerySurface failed with error "
                  << GetLastEGLErrorString();
     return gfx::Size();
   }
 
   return gfx::Size(width, height);
 #endif
 }
 
 void* NativeViewEGLContext::GetHandle() {
   return context_;
 }
 
 void NativeViewEGLContext::SetSwapInterval(int interval) {
   DCHECK(IsCurrent());
   if (!eglSwapInterval(g_display, interval)) {
     LOG(ERROR) << "eglSwapInterval failed with error "
                << GetLastEGLErrorString();
   }
 }
 
-EGLSurface NativeViewEGLContext::GetSurface() {
+SharedEGLSurface* NativeViewEGLContext::GetSurface() {
   return surface_;
 }
 
 SecondaryEGLContext::SecondaryEGLContext()
-    : surface_(NULL),
-      own_surface_(false),
-      context_(NULL)
+    : context_(NULL)
 {
 }
 
 SecondaryEGLContext::~SecondaryEGLContext() {
 }
 
 bool SecondaryEGLContext::Initialize(GLContext* shared_context) {
   DCHECK(!context_);
 
   static const EGLint kContextAttributes[] = {
     EGL_CONTEXT_CLIENT_VERSION, 2,
     EGL_NONE
   };
 
   if (shared_context) {
     surface_ = static_cast<BaseEGLContext*>(shared_context)->GetSurface();
-    own_surface_ = false;
 
     // Create a context.
     context_ = eglCreateContext(g_display,
                                 g_config,
                                 shared_context->GetHandle(),
                                 kContextAttributes);
   } else {
 #ifdef EGL_HAS_PBUFFERS
     static const EGLint kPbufferAttribs[] = {
       EGL_WIDTH, 1,
       EGL_HEIGHT, 1,
       EGL_NONE
     };
 
-    surface_ = eglCreatePbufferSurface(g_display, g_config, kPbufferAttribs);
-    if (!surface_) {
+    surface_ = new SharedEGLSurface(eglCreatePbufferSurface(g_display,
+                                                            g_config,
+                                                            kPbufferAttribs));
+    if (!surface_->egl_surface()) {
       LOG(ERROR) << "eglCreatePbufferSurface failed with error "
                  << GetLastEGLErrorString();
+      Destroy();
       return false;
     }
-    own_surface_ = true;
 
     context_ = eglCreateContext(g_display, g_config, NULL, kContextAttributes);
 #else
     NOTIMPLEMENTED() << "Offscreen non-shared GLES context";
     return false;
 #endif
   }
 
   if (!context_) {
     LOG(ERROR) << "eglCreateContext failed with error "
                << GetLastEGLErrorString();
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void SecondaryEGLContext::Destroy() {
-  if (own_surface_) {
-    if (!eglDestroySurface(g_display, surface_)) {
-      LOG(ERROR) << "eglDestroySurface failed with error "
-                 << GetLastEGLErrorString();
-    }
-
-    own_surface_ = false;
-  }
-  surface_ = NULL;
-
   if (context_) {
     if (!eglDestroyContext(g_display, context_)) {
       LOG(ERROR) << "eglDestroyContext failed with error "
                  << GetLastEGLErrorString();
     }
 
     context_ = NULL;
   }
+
+  surface_ = NULL;
 }
 
 bool SecondaryEGLContext::MakeCurrent() {
   DCHECK(context_);
   if (!eglMakeCurrent(g_display,
-                      surface_, surface_,
+                      surface_->egl_surface(),
+                      surface_->egl_surface(),
                       context_)) {
     VLOG(1) << "eglMakeCurrent failed with error "
             << GetLastEGLErrorString();
     return false;
   }
 
   return true;
 }
 
 bool SecondaryEGLContext::IsCurrent() {
@@ skipping 17 matching lines @@
 
 void* SecondaryEGLContext::GetHandle() {
   return context_;
 }
 
 void SecondaryEGLContext::SetSwapInterval(int interval) {
   DCHECK(IsCurrent());
   NOTREACHED() << "Attempt to call SetSwapInterval on a SecondaryEGLContext.";
 }
 
-EGLSurface SecondaryEGLContext::GetSurface() {
+SharedEGLSurface* SecondaryEGLContext::GetSurface() {
   return surface_;
 }
 
 }  // namespace gfx