During image destroy, delete textures only if we have a GL context.

ui/gl/gl_image_glx.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.
 
 extern "C" {
 #include <X11/extensions/Xcomposite.h>
 }
 
 #include "ui/gl/gl_image_glx.h"
 
@@ skipping 31 matching lines @@
 }
 
 }  // namespace anonymous
 
 GLImageGLX::GLImageGLX(gfx::PluginWindowHandle window)
     : display_(gfx::GetXDisplay()),
       window_(window),
       pixmap_(0),
       glx_pixmap_(0) {}
 
-GLImageGLX::~GLImageGLX() { Destroy(); }
+GLImageGLX::~GLImageGLX() {
+  DCHECK_EQ(0u, glx_pixmap_);
+  DCHECK_EQ(0u, pixmap_);
+}
 
 bool GLImageGLX::Initialize() {
   if (!GLSurfaceGLX::IsTextureFromPixmapSupported()) {
     LOG(ERROR) << "GLX_EXT_texture_from_pixmap not supported.";
     return false;
   }
 
   XWindowAttributes attributes;
   if (!XGetWindowAttributes(display_, window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
@@ skipping 28 matching lines @@
     LOG(ERROR) << "glXChooseFBConfig failed.";
     return false;
   }
   if (!num_elements) {
     LOG(ERROR) << "glXChooseFBConfig returned 0 elements.";
     return false;
   }
 
   // Create backing pixmap reference.
   pixmap_ = XCompositeNameWindowPixmap(display_, window_);
+  if (!pixmap_) {
+    LOG(ERROR) << "XCompositeNameWindowPixmap failed.";
+    return false;
+  }
 
   XID root = 0;
   int x = 0;
   int y = 0;
   unsigned int width = 0;
   unsigned int height = 0;
   unsigned int bw = 0;
   unsigned int depth = 0;
   if (!XGetGeometry(
           display_, pixmap_, &root, &x, &y, &width, &height, &bw, &depth)) {
     LOG(ERROR) << "XGetGeometry failed for pixmap " << pixmap_ << ".";
+    XFreePixmap(display_, pixmap_);
+    pixmap_ = 0u;
     return false;
   }
 
   int pixmap_attribs[] = {GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
                           GLX_TEXTURE_FORMAT_EXT, TextureFormat(visinfo->depth),
                           0};
   glx_pixmap_ =
       glXCreatePixmap(display_, *config.get(), pixmap_, pixmap_attribs);
   if (!glx_pixmap_) {
     LOG(ERROR) << "glXCreatePixmap failed.";
+    XFreePixmap(display_, pixmap_);
+    pixmap_ = 0u;
     return false;
   }
 
   size_ = gfx::Size(width, height);
   return true;
 }
 
-void GLImageGLX::Destroy() {
+void GLImageGLX::Destroy(bool have_context) {
   if (glx_pixmap_) {
     glXDestroyGLXPixmap(display_, glx_pixmap_);
     glx_pixmap_ = 0;
   }
   if (pixmap_) {
     XFreePixmap(display_, pixmap_);
     pixmap_ = 0;
   }
 }
 
@@ skipping 12 matching lines @@
 }
 
 void GLImageGLX::ReleaseTexImage(unsigned target) {
   DCHECK(glx_pixmap_);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), target);
 
   glXReleaseTexImageEXT(display_, glx_pixmap_, GLX_FRONT_LEFT_EXT);
 }
 
 }  // namespace gfx