Home | History | Annotate | Download | only in gl 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 extern "C" {
      6 #include <X11/Xlib.h>
      7 }
      8 
      9 #include "ui/gl/gl_surface_glx.h"
     10 
     11 #include "base/basictypes.h"
     12 #include "base/debug/trace_event.h"
     13 #include "base/lazy_instance.h"
     14 #include "base/logging.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/memory/weak_ptr.h"
     17 #include "base/message_loop/message_loop.h"
     18 #include "base/synchronization/cancellation_flag.h"
     19 #include "base/synchronization/lock.h"
     20 #include "base/threading/non_thread_safe.h"
     21 #include "base/threading/thread.h"
     22 #include "base/time/time.h"
     23 #include "third_party/mesa/src/include/GL/osmesa.h"
     24 #include "ui/events/platform/platform_event_source.h"
     25 #include "ui/gfx/x/x11_connection.h"
     26 #include "ui/gfx/x/x11_types.h"
     27 #include "ui/gl/gl_bindings.h"
     28 #include "ui/gl/gl_implementation.h"
     29 #include "ui/gl/sync_control_vsync_provider.h"
     30 
     31 namespace gfx {
     32 
     33 namespace {
     34 
     35 // scoped_ptr functor for XFree(). Use as follows:
     36 //   scoped_ptr<XVisualInfo, ScopedPtrXFree> foo(...);
     37 // where "XVisualInfo" is any X type that is freed with XFree.
     38 struct ScopedPtrXFree {
     39   void operator()(void* x) const {
     40     ::XFree(x);
     41   }
     42 };
     43 
     44 Display* g_display = NULL;
     45 const char* g_glx_extensions = NULL;
     46 bool g_glx_context_create = false;
     47 bool g_glx_create_context_robustness_supported = false;
     48 bool g_glx_texture_from_pixmap_supported = false;
     49 bool g_glx_oml_sync_control_supported = false;
     50 
     51 // Track support of glXGetMscRateOML separately from GLX_OML_sync_control as a
     52 // whole since on some platforms (e.g. crosbug.com/34585), glXGetMscRateOML
     53 // always fails even though GLX_OML_sync_control is reported as being supported.
     54 bool g_glx_get_msc_rate_oml_supported = false;
     55 
     56 bool g_glx_sgi_video_sync_supported = false;
     57 
     58 class OMLSyncControlVSyncProvider
     59     : public gfx::SyncControlVSyncProvider {
     60  public:
     61   explicit OMLSyncControlVSyncProvider(gfx::AcceleratedWidget window)
     62       : SyncControlVSyncProvider(),
     63         window_(window) {
     64   }
     65 
     66   virtual ~OMLSyncControlVSyncProvider() { }
     67 
     68  protected:
     69   virtual bool GetSyncValues(int64* system_time,
     70                              int64* media_stream_counter,
     71                              int64* swap_buffer_counter) OVERRIDE {
     72     return glXGetSyncValuesOML(g_display, window_, system_time,
     73                                media_stream_counter, swap_buffer_counter);
     74   }
     75 
     76   virtual bool GetMscRate(int32* numerator, int32* denominator) OVERRIDE {
     77     if (!g_glx_get_msc_rate_oml_supported)
     78       return false;
     79 
     80     if (!glXGetMscRateOML(g_display, window_, numerator, denominator)) {
     81       // Once glXGetMscRateOML has been found to fail, don't try again,
     82       // since each failing call may spew an error message.
     83       g_glx_get_msc_rate_oml_supported = false;
     84       return false;
     85     }
     86 
     87     return true;
     88   }
     89 
     90  private:
     91   XID window_;
     92 
     93   DISALLOW_COPY_AND_ASSIGN(OMLSyncControlVSyncProvider);
     94 };
     95 
     96 class SGIVideoSyncThread
     97      : public base::Thread,
     98        public base::NonThreadSafe,
     99        public base::RefCounted<SGIVideoSyncThread> {
    100  public:
    101   static scoped_refptr<SGIVideoSyncThread> Create() {
    102     if (!g_video_sync_thread) {
    103       g_video_sync_thread = new SGIVideoSyncThread();
    104       g_video_sync_thread->Start();
    105     }
    106     return g_video_sync_thread;
    107   }
    108 
    109  private:
    110   friend class base::RefCounted<SGIVideoSyncThread>;
    111 
    112   SGIVideoSyncThread() : base::Thread("SGI_video_sync") {
    113     DCHECK(CalledOnValidThread());
    114   }
    115 
    116   virtual ~SGIVideoSyncThread() {
    117     DCHECK(CalledOnValidThread());
    118     g_video_sync_thread = NULL;
    119     Stop();
    120   }
    121 
    122   static SGIVideoSyncThread* g_video_sync_thread;
    123 
    124   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncThread);
    125 };
    126 
    127 class SGIVideoSyncProviderThreadShim {
    128  public:
    129   explicit SGIVideoSyncProviderThreadShim(XID window)
    130       : window_(window),
    131         context_(NULL),
    132         message_loop_(base::MessageLoopProxy::current()),
    133         cancel_vsync_flag_(),
    134         vsync_lock_() {
    135     // This ensures that creation of |window_| has occured when this shim
    136     // is executing in the same process as the call to create |window_|.
    137     XSync(g_display, False);
    138   }
    139 
    140   virtual ~SGIVideoSyncProviderThreadShim() {
    141     if (context_) {
    142       glXDestroyContext(display_, context_);
    143       context_ = NULL;
    144     }
    145   }
    146 
    147   base::CancellationFlag* cancel_vsync_flag() {
    148     return &cancel_vsync_flag_;
    149   }
    150 
    151   base::Lock* vsync_lock() {
    152     return &vsync_lock_;
    153   }
    154 
    155   void Initialize() {
    156     DCHECK(display_);
    157 
    158     XWindowAttributes attributes;
    159     if (!XGetWindowAttributes(display_, window_, &attributes)) {
    160       LOG(ERROR) << "XGetWindowAttributes failed for window " <<
    161         window_ << ".";
    162       return;
    163     }
    164 
    165     XVisualInfo visual_info_template;
    166     visual_info_template.visualid = XVisualIDFromVisual(attributes.visual);
    167 
    168     int visual_info_count = 0;
    169     scoped_ptr<XVisualInfo, ScopedPtrXFree> visual_info_list(
    170         XGetVisualInfo(display_, VisualIDMask,
    171                        &visual_info_template, &visual_info_count));
    172 
    173     DCHECK(visual_info_list.get());
    174     if (visual_info_count == 0) {
    175       LOG(ERROR) << "No visual info for visual ID.";
    176       return;
    177     }
    178 
    179     context_ = glXCreateContext(display_, visual_info_list.get(), NULL, True);
    180 
    181     DCHECK(NULL != context_);
    182   }
    183 
    184   void GetVSyncParameters(const VSyncProvider::UpdateVSyncCallback& callback) {
    185     base::TimeTicks now;
    186     {
    187       // Don't allow |window_| destruction while we're probing vsync.
    188       base::AutoLock locked(vsync_lock_);
    189 
    190       if (!context_ || cancel_vsync_flag_.IsSet())
    191         return;
    192 
    193       glXMakeCurrent(display_, window_, context_);
    194 
    195       unsigned int retrace_count = 0;
    196       if (glXWaitVideoSyncSGI(1, 0, &retrace_count) != 0)
    197         return;
    198 
    199       TRACE_EVENT_INSTANT0("gpu", "vblank", TRACE_EVENT_SCOPE_THREAD);
    200       now = base::TimeTicks::HighResNow();
    201 
    202       glXMakeCurrent(display_, 0, 0);
    203     }
    204 
    205     const base::TimeDelta kDefaultInterval =
    206         base::TimeDelta::FromSeconds(1) / 60;
    207 
    208     message_loop_->PostTask(
    209         FROM_HERE, base::Bind(callback, now, kDefaultInterval));
    210   }
    211 
    212  private:
    213   // For initialization of display_ in GLSurface::InitializeOneOff before
    214   // the sandbox goes up.
    215   friend class gfx::GLSurfaceGLX;
    216 
    217   static Display* display_;
    218 
    219   XID window_;
    220   GLXContext context_;
    221 
    222   scoped_refptr<base::MessageLoopProxy> message_loop_;
    223 
    224   base::CancellationFlag cancel_vsync_flag_;
    225   base::Lock vsync_lock_;
    226 
    227   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncProviderThreadShim);
    228 };
    229 
    230 class SGIVideoSyncVSyncProvider
    231     : public gfx::VSyncProvider,
    232       public base::SupportsWeakPtr<SGIVideoSyncVSyncProvider> {
    233  public:
    234   explicit SGIVideoSyncVSyncProvider(gfx::AcceleratedWidget window)
    235       : vsync_thread_(SGIVideoSyncThread::Create()),
    236         shim_(new SGIVideoSyncProviderThreadShim(window)),
    237         cancel_vsync_flag_(shim_->cancel_vsync_flag()),
    238         vsync_lock_(shim_->vsync_lock()) {
    239     vsync_thread_->message_loop()->PostTask(
    240         FROM_HERE,
    241         base::Bind(&SGIVideoSyncProviderThreadShim::Initialize,
    242                    base::Unretained(shim_.get())));
    243   }
    244 
    245   virtual ~SGIVideoSyncVSyncProvider() {
    246     {
    247       base::AutoLock locked(*vsync_lock_);
    248       cancel_vsync_flag_->Set();
    249     }
    250 
    251     // Hand-off |shim_| to be deleted on the |vsync_thread_|.
    252     vsync_thread_->message_loop()->DeleteSoon(
    253         FROM_HERE,
    254         shim_.release());
    255   }
    256 
    257   virtual void GetVSyncParameters(
    258       const VSyncProvider::UpdateVSyncCallback& callback) OVERRIDE {
    259     // Only one outstanding request per surface.
    260     if (!pending_callback_) {
    261       pending_callback_.reset(
    262           new VSyncProvider::UpdateVSyncCallback(callback));
    263       vsync_thread_->message_loop()->PostTask(
    264           FROM_HERE,
    265           base::Bind(&SGIVideoSyncProviderThreadShim::GetVSyncParameters,
    266                      base::Unretained(shim_.get()),
    267                      base::Bind(
    268                          &SGIVideoSyncVSyncProvider::PendingCallbackRunner,
    269                          AsWeakPtr())));
    270     }
    271   }
    272 
    273  private:
    274   void PendingCallbackRunner(const base::TimeTicks timebase,
    275                              const base::TimeDelta interval) {
    276     DCHECK(pending_callback_);
    277     pending_callback_->Run(timebase, interval);
    278     pending_callback_.reset();
    279   }
    280 
    281   scoped_refptr<SGIVideoSyncThread> vsync_thread_;
    282 
    283   // Thread shim through which the sync provider is accessed on |vsync_thread_|.
    284   scoped_ptr<SGIVideoSyncProviderThreadShim> shim_;
    285 
    286   scoped_ptr<VSyncProvider::UpdateVSyncCallback> pending_callback_;
    287 
    288   // Raw pointers to sync primitives owned by the shim_.
    289   // These will only be referenced before we post a task to destroy
    290   // the shim_, so they are safe to access.
    291   base::CancellationFlag* cancel_vsync_flag_;
    292   base::Lock* vsync_lock_;
    293 
    294   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncVSyncProvider);
    295 };
    296 
    297 SGIVideoSyncThread* SGIVideoSyncThread::g_video_sync_thread = NULL;
    298 
    299 // In order to take advantage of GLX_SGI_video_sync, we need a display
    300 // for use on a separate thread. We must allocate this before the sandbox
    301 // goes up (rather than on-demand when we start the thread).
    302 Display* SGIVideoSyncProviderThreadShim::display_ = NULL;
    303 
    304 }  // namespace
    305 
    306 GLSurfaceGLX::GLSurfaceGLX() {}
    307 
    308 bool GLSurfaceGLX::InitializeOneOff() {
    309   static bool initialized = false;
    310   if (initialized)
    311     return true;
    312 
    313   // http://crbug.com/245466
    314   setenv("force_s3tc_enable", "true", 1);
    315 
    316   // SGIVideoSyncProviderShim (if instantiated) will issue X commands on
    317   // it's own thread.
    318   gfx::InitializeThreadedX11();
    319   g_display = gfx::GetXDisplay();
    320 
    321   if (!g_display) {
    322     LOG(ERROR) << "XOpenDisplay failed.";
    323     return false;
    324   }
    325 
    326   int major, minor;
    327   if (!glXQueryVersion(g_display, &major, &minor)) {
    328     LOG(ERROR) << "glxQueryVersion failed";
    329     return false;
    330   }
    331 
    332   if (major == 1 && minor < 3) {
    333     LOG(ERROR) << "GLX 1.3 or later is required.";
    334     return false;
    335   }
    336 
    337   g_glx_extensions = glXQueryExtensionsString(g_display, 0);
    338   g_glx_context_create =
    339       HasGLXExtension("GLX_ARB_create_context");
    340   g_glx_create_context_robustness_supported =
    341       HasGLXExtension("GLX_ARB_create_context_robustness");
    342   g_glx_texture_from_pixmap_supported =
    343       HasGLXExtension("GLX_EXT_texture_from_pixmap");
    344   g_glx_oml_sync_control_supported =
    345       HasGLXExtension("GLX_OML_sync_control");
    346   g_glx_get_msc_rate_oml_supported = g_glx_oml_sync_control_supported;
    347   g_glx_sgi_video_sync_supported =
    348       HasGLXExtension("GLX_SGI_video_sync");
    349 
    350   if (!g_glx_get_msc_rate_oml_supported && g_glx_sgi_video_sync_supported)
    351     SGIVideoSyncProviderThreadShim::display_ = gfx::OpenNewXDisplay();
    352 
    353   initialized = true;
    354   return true;
    355 }
    356 
    357 // static
    358 const char* GLSurfaceGLX::GetGLXExtensions() {
    359   return g_glx_extensions;
    360 }
    361 
    362 // static
    363 bool GLSurfaceGLX::HasGLXExtension(const char* name) {
    364   return ExtensionsContain(GetGLXExtensions(), name);
    365 }
    366 
    367 // static
    368 bool GLSurfaceGLX::IsCreateContextSupported() {
    369   return g_glx_context_create;
    370 }
    371 
    372 // static
    373 bool GLSurfaceGLX::IsCreateContextRobustnessSupported() {
    374   return g_glx_create_context_robustness_supported;
    375 }
    376 
    377 // static
    378 bool GLSurfaceGLX::IsTextureFromPixmapSupported() {
    379   return g_glx_texture_from_pixmap_supported;
    380 }
    381 
    382 // static
    383 bool GLSurfaceGLX::IsOMLSyncControlSupported() {
    384   return g_glx_oml_sync_control_supported;
    385 }
    386 
    387 void* GLSurfaceGLX::GetDisplay() {
    388   return g_display;
    389 }
    390 
    391 GLSurfaceGLX::~GLSurfaceGLX() {}
    392 
    393 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window)
    394   : parent_window_(window),
    395     window_(0),
    396     config_(NULL) {
    397 }
    398 
    399 gfx::AcceleratedWidget NativeViewGLSurfaceGLX::GetDrawableHandle() const {
    400   return window_;
    401 }
    402 
    403 bool NativeViewGLSurfaceGLX::Initialize() {
    404   XWindowAttributes attributes;
    405   if (!XGetWindowAttributes(g_display, parent_window_, &attributes)) {
    406     LOG(ERROR) << "XGetWindowAttributes failed for window " << parent_window_
    407         << ".";
    408     return false;
    409   }
    410   size_ = gfx::Size(attributes.width, attributes.height);
    411   // Create a child window, with a CopyFromParent visual (to avoid inducing
    412   // extra blits in the driver), that we can resize exactly in Resize(),
    413   // correctly ordered with GL, so that we don't have invalid transient states.
    414   // See https://crbug.com/326995.
    415   window_ = XCreateWindow(g_display,
    416                           parent_window_,
    417                           0,
    418                           0,
    419                           size_.width(),
    420                           size_.height(),
    421                           0,
    422                           CopyFromParent,
    423                           InputOutput,
    424                           CopyFromParent,
    425                           0,
    426                           NULL);
    427   XMapWindow(g_display, window_);
    428 
    429   ui::PlatformEventSource* event_source =
    430       ui::PlatformEventSource::GetInstance();
    431   // Can be NULL in tests, when we don't care about Exposes.
    432   if (event_source) {
    433     XSelectInput(g_display, window_, ExposureMask);
    434     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
    435   }
    436   XFlush(g_display);
    437 
    438   gfx::AcceleratedWidget window_for_vsync = window_;
    439 
    440   if (g_glx_oml_sync_control_supported)
    441     vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_for_vsync));
    442   else if (g_glx_sgi_video_sync_supported)
    443     vsync_provider_.reset(new SGIVideoSyncVSyncProvider(window_for_vsync));
    444 
    445   return true;
    446 }
    447 
    448 void NativeViewGLSurfaceGLX::Destroy() {
    449   if (window_) {
    450     ui::PlatformEventSource* event_source =
    451         ui::PlatformEventSource::GetInstance();
    452     if (event_source)
    453       event_source->RemovePlatformEventDispatcher(this);
    454     XDestroyWindow(g_display, window_);
    455     XFlush(g_display);
    456   }
    457 }
    458 
    459 bool NativeViewGLSurfaceGLX::CanDispatchEvent(const ui::PlatformEvent& event) {
    460   return event->type == Expose && event->xexpose.window == window_;
    461 }
    462 
    463 uint32_t NativeViewGLSurfaceGLX::DispatchEvent(const ui::PlatformEvent& event) {
    464   XEvent forwarded_event = *event;
    465   forwarded_event.xexpose.window = parent_window_;
    466   XSendEvent(g_display, parent_window_, False, ExposureMask,
    467              &forwarded_event);
    468   XFlush(g_display);
    469   return ui::POST_DISPATCH_STOP_PROPAGATION;
    470 }
    471 
    472 bool NativeViewGLSurfaceGLX::Resize(const gfx::Size& size) {
    473   size_ = size;
    474   glXWaitGL();
    475   XResizeWindow(g_display, window_, size.width(), size.height());
    476   glXWaitX();
    477   return true;
    478 }
    479 
    480 bool NativeViewGLSurfaceGLX::IsOffscreen() {
    481   return false;
    482 }
    483 
    484 bool NativeViewGLSurfaceGLX::SwapBuffers() {
    485   TRACE_EVENT2("gpu", "NativeViewGLSurfaceGLX:RealSwapBuffers",
    486       "width", GetSize().width(),
    487       "height", GetSize().height());
    488 
    489   glXSwapBuffers(g_display, GetDrawableHandle());
    490   return true;
    491 }
    492 
    493 gfx::Size NativeViewGLSurfaceGLX::GetSize() {
    494   return size_;
    495 }
    496 
    497 void* NativeViewGLSurfaceGLX::GetHandle() {
    498   return reinterpret_cast<void*>(GetDrawableHandle());
    499 }
    500 
    501 bool NativeViewGLSurfaceGLX::SupportsPostSubBuffer() {
    502   return gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer;
    503 }
    504 
    505 void* NativeViewGLSurfaceGLX::GetConfig() {
    506   if (!config_) {
    507     // This code path is expensive, but we only take it when
    508     // attempting to use GLX_ARB_create_context_robustness, in which
    509     // case we need a GLXFBConfig for the window in order to create a
    510     // context for it.
    511     //
    512     // TODO(kbr): this is not a reliable code path. On platforms which
    513     // support it, we should use glXChooseFBConfig in the browser
    514     // process to choose the FBConfig and from there the X Visual to
    515     // use when creating the window in the first place. Then we can
    516     // pass that FBConfig down rather than attempting to reconstitute
    517     // it.
    518 
    519     XWindowAttributes attributes;
    520     if (!XGetWindowAttributes(
    521         g_display,
    522         window_,
    523         &attributes)) {
    524       LOG(ERROR) << "XGetWindowAttributes failed for window " <<
    525           window_ << ".";
    526       return NULL;
    527     }
    528 
    529     int visual_id = XVisualIDFromVisual(attributes.visual);
    530 
    531     int num_elements = 0;
    532     scoped_ptr<GLXFBConfig, ScopedPtrXFree> configs(
    533         glXGetFBConfigs(g_display,
    534                         DefaultScreen(g_display),
    535                         &num_elements));
    536     if (!configs.get()) {
    537       LOG(ERROR) << "glXGetFBConfigs failed.";
    538       return NULL;
    539     }
    540     if (!num_elements) {
    541       LOG(ERROR) << "glXGetFBConfigs returned 0 elements.";
    542       return NULL;
    543     }
    544     bool found = false;
    545     int i;
    546     for (i = 0; i < num_elements; ++i) {
    547       int value;
    548       if (glXGetFBConfigAttrib(
    549               g_display, configs.get()[i], GLX_VISUAL_ID, &value)) {
    550         LOG(ERROR) << "glXGetFBConfigAttrib failed.";
    551         return NULL;
    552       }
    553       if (value == visual_id) {
    554         found = true;
    555         break;
    556       }
    557     }
    558     if (found) {
    559       config_ = configs.get()[i];
    560     }
    561   }
    562 
    563   return config_;
    564 }
    565 
    566 bool NativeViewGLSurfaceGLX::PostSubBuffer(
    567     int x, int y, int width, int height) {
    568   DCHECK(gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
    569   glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
    570   return true;
    571 }
    572 
    573 VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
    574   return vsync_provider_.get();
    575 }
    576 
    577 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
    578   Destroy();
    579 }
    580 
    581 PbufferGLSurfaceGLX::PbufferGLSurfaceGLX(const gfx::Size& size)
    582   : size_(size),
    583     config_(NULL),
    584     pbuffer_(0) {
    585   // Some implementations of Pbuffer do not support having a 0 size. For such
    586   // cases use a (1, 1) surface.
    587   if (size_.GetArea() == 0)
    588     size_.SetSize(1, 1);
    589 }
    590 
    591 bool PbufferGLSurfaceGLX::Initialize() {
    592   DCHECK(!pbuffer_);
    593 
    594   static const int config_attributes[] = {
    595     GLX_BUFFER_SIZE, 32,
    596     GLX_ALPHA_SIZE, 8,
    597     GLX_BLUE_SIZE, 8,
    598     GLX_GREEN_SIZE, 8,
    599     GLX_RED_SIZE, 8,
    600     GLX_RENDER_TYPE, GLX_RGBA_BIT,
    601     GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
    602     GLX_DOUBLEBUFFER, False,
    603     0
    604   };
    605 
    606   int num_elements = 0;
    607   scoped_ptr<GLXFBConfig, ScopedPtrXFree> configs(
    608       glXChooseFBConfig(g_display,
    609                         DefaultScreen(g_display),
    610                         config_attributes,
    611                         &num_elements));
    612   if (!configs.get()) {
    613     LOG(ERROR) << "glXChooseFBConfig failed.";
    614     return false;
    615   }
    616   if (!num_elements) {
    617     LOG(ERROR) << "glXChooseFBConfig returned 0 elements.";
    618     return false;
    619   }
    620 
    621   config_ = configs.get()[0];
    622 
    623   const int pbuffer_attributes[] = {
    624     GLX_PBUFFER_WIDTH, size_.width(),
    625     GLX_PBUFFER_HEIGHT, size_.height(),
    626     0
    627   };
    628   pbuffer_ = glXCreatePbuffer(g_display,
    629                               static_cast<GLXFBConfig>(config_),
    630                               pbuffer_attributes);
    631   if (!pbuffer_) {
    632     Destroy();
    633     LOG(ERROR) << "glXCreatePbuffer failed.";
    634     return false;
    635   }
    636 
    637   return true;
    638 }
    639 
    640 void PbufferGLSurfaceGLX::Destroy() {
    641   if (pbuffer_) {
    642     glXDestroyPbuffer(g_display, pbuffer_);
    643     pbuffer_ = 0;
    644   }
    645 
    646   config_ = NULL;
    647 }
    648 
    649 bool PbufferGLSurfaceGLX::IsOffscreen() {
    650   return true;
    651 }
    652 
    653 bool PbufferGLSurfaceGLX::SwapBuffers() {
    654   NOTREACHED() << "Attempted to call SwapBuffers on a pbuffer.";
    655   return false;
    656 }
    657 
    658 gfx::Size PbufferGLSurfaceGLX::GetSize() {
    659   return size_;
    660 }
    661 
    662 void* PbufferGLSurfaceGLX::GetHandle() {
    663   return reinterpret_cast<void*>(pbuffer_);
    664 }
    665 
    666 void* PbufferGLSurfaceGLX::GetConfig() {
    667   return config_;
    668 }
    669 
    670 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
    671   Destroy();
    672 }
    673 
    674 }  // namespace gfx
    675