ui/gl/gl_surface_glx.cc

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