ui: No more TestCompositor. Use NullDraw contexts in unit tests.

ui/gl/gl_surface_x11.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.
 
 #include "ui/gl/gl_surface.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "third_party/mesa/src/include/GL/osmesa.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_glx.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 
 namespace gfx {
 
-namespace {
-Display* g_osmesa_display;
-}  // namespace
-
 // This OSMesa GL surface can use XLib to swap the contents of the buffer to a
 // view.
 class NativeViewGLSurfaceOSMesa : public GLSurfaceOSMesa {
  public:
   explicit NativeViewGLSurfaceOSMesa(gfx::AcceleratedWidget window);
 
   static bool InitializeOneOff();
 
   // Implement a subset of GLSurface.
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool Resize(const gfx::Size& new_size) OVERRIDE;
   virtual bool IsOffscreen() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
   virtual std::string GetExtensions() OVERRIDE;
   virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
 
  protected:
   virtual ~NativeViewGLSurfaceOSMesa();
 
  private:
+  Display* xdisplay_;
   GC window_graphics_context_;
   gfx::AcceleratedWidget window_;
   GC pixmap_graphics_context_;
   Pixmap pixmap_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceOSMesa);
 };
 
 bool GLSurface::InitializeOneOffInternal() {
   switch (GetGLImplementation()) {
@@ skipping 17 matching lines @@
       break;
     default:
       break;
   }
 
   return true;
 }
 
 NativeViewGLSurfaceOSMesa::NativeViewGLSurfaceOSMesa(
     gfx::AcceleratedWidget window)
-  : GLSurfaceOSMesa(OSMESA_BGRA, gfx::Size(1, 1)),
-    window_graphics_context_(0),
-    window_(window),
-    pixmap_graphics_context_(0),
-    pixmap_(0) {
-  DCHECK(window);
+    : GLSurfaceOSMesa(OSMESA_BGRA, gfx::Size(1, 1)),
+      xdisplay_(base::MessagePumpForUI::GetDefaultXDisplay()),
+      window_graphics_context_(0),
+      window_(window),
+      pixmap_graphics_context_(0),
+      pixmap_(0) {
+  DCHECK(xdisplay_);
+  DCHECK(window_);
 }
 
+// static
 bool NativeViewGLSurfaceOSMesa::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
-  g_osmesa_display = base::MessagePumpForUI::GetDefaultXDisplay();
-  if (!g_osmesa_display) {
+  if (!base::MessagePumpForUI::GetDefaultXDisplay()) {
     LOG(ERROR) << "XOpenDisplay failed.";
     return false;
   }
 
   initialized = true;
   return true;
 }
 
 bool NativeViewGLSurfaceOSMesa::Initialize() {
   if (!GLSurfaceOSMesa::Initialize())
     return false;
 
-  window_graphics_context_ = XCreateGC(g_osmesa_display,
-                                       window_,
-                                       0,
-                                       NULL);
+  window_graphics_context_ = XCreateGC(xdisplay_, window_, 0, NULL);
   if (!window_graphics_context_) {
     LOG(ERROR) << "XCreateGC failed.";
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void NativeViewGLSurfaceOSMesa::Destroy() {
   if (pixmap_graphics_context_) {
-    XFreeGC(g_osmesa_display, pixmap_graphics_context_);
+    XFreeGC(xdisplay_, pixmap_graphics_context_);
     pixmap_graphics_context_ = NULL;
   }
 
   if (pixmap_) {
-    XFreePixmap(g_osmesa_display, pixmap_);
+    XFreePixmap(xdisplay_, pixmap_);
     pixmap_ = 0;
   }
 
   if (window_graphics_context_) {
-    XFreeGC(g_osmesa_display, window_graphics_context_);
+    XFreeGC(xdisplay_, window_graphics_context_);
     window_graphics_context_ = NULL;
   }
 
-  XSync(g_osmesa_display, False);
+  XSync(xdisplay_, False);
 }
 
 bool NativeViewGLSurfaceOSMesa::Resize(const gfx::Size& new_size) {
   if (!GLSurfaceOSMesa::Resize(new_size))
     return false;
 
   XWindowAttributes attributes;
-  if (!XGetWindowAttributes(g_osmesa_display, window_, &attributes)) {
+  if (!XGetWindowAttributes(xdisplay_, window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
     return false;
   }
 
   // Destroy the previous pixmap and graphics context.
   if (pixmap_graphics_context_) {
-    XFreeGC(g_osmesa_display, pixmap_graphics_context_);
+    XFreeGC(xdisplay_, pixmap_graphics_context_);
     pixmap_graphics_context_ = NULL;
   }
   if (pixmap_) {
-    XFreePixmap(g_osmesa_display, pixmap_);
+    XFreePixmap(xdisplay_, pixmap_);
     pixmap_ = 0;
   }
 
   // Recreate a pixmap to hold the frame.
-  pixmap_ = XCreatePixmap(g_osmesa_display,
+  pixmap_ = XCreatePixmap(xdisplay_,
                           window_,
                           new_size.width(),
                           new_size.height(),
                           attributes.depth);
   if (!pixmap_) {
     LOG(ERROR) << "XCreatePixmap failed.";
     return false;
   }
 
   // Recreate a graphics context for the pixmap.
-  pixmap_graphics_context_ = XCreateGC(g_osmesa_display, pixmap_, 0, NULL);
+  pixmap_graphics_context_ = XCreateGC(xdisplay_, pixmap_, 0, NULL);
   if (!pixmap_graphics_context_) {
     LOG(ERROR) << "XCreateGC failed";
     return false;
   }
 
   return true;
 }
 
 bool NativeViewGLSurfaceOSMesa::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceOSMesa::SwapBuffers() {
   TRACE_EVENT2("gpu", "NativeViewGLSurfaceOSMesa:RealSwapBuffers",
       "width", GetSize().width(),
       "height", GetSize().height());
 
   gfx::Size size = GetSize();
 
   XWindowAttributes attributes;
-  if (!XGetWindowAttributes(g_osmesa_display, window_, &attributes)) {
+  if (!XGetWindowAttributes(xdisplay_, window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
     return false;
   }
 
   // Copy the frame into the pixmap.
-  gfx::PutARGBImage(g_osmesa_display,
+  gfx::PutARGBImage(xdisplay_,
                     attributes.visual,
                     attributes.depth,
                     pixmap_,
                     pixmap_graphics_context_,
                     static_cast<const uint8*>(GetHandle()),
                     size.width(),
                     size.height());
 
   // Copy the pixmap to the window.
-  XCopyArea(g_osmesa_display,
+  XCopyArea(xdisplay_,
             pixmap_,
             window_,
             window_graphics_context_,
-            0, 0,
-            size.width(), size.height(),
-            0, 0);
+            0,
+            0,
+            size.width(),
+            size.height(),
+            0,
+            0);
 
   return true;
 }
 
 std::string NativeViewGLSurfaceOSMesa::GetExtensions() {
   std::string extensions = gfx::GLSurfaceOSMesa::GetExtensions();
   extensions += extensions.empty() ? "" : " ";
   extensions += "GL_CHROMIUM_post_sub_buffer";
   return extensions;
 }
 
 bool NativeViewGLSurfaceOSMesa::PostSubBuffer(
     int x, int y, int width, int height) {
   gfx::Size size = GetSize();
 
   // Move (0,0) from lower-left to upper-left
   y = size.height() - y - height;
 
   XWindowAttributes attributes;
-  if (!XGetWindowAttributes(g_osmesa_display, window_, &attributes)) {
+  if (!XGetWindowAttributes(xdisplay_, window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
     return false;
   }
 
   // Copy the frame into the pixmap.
-  gfx::PutARGBImage(g_osmesa_display,
+  gfx::PutARGBImage(xdisplay_,
                     attributes.visual,
                     attributes.depth,
                     pixmap_,
                     pixmap_graphics_context_,
                     static_cast<const uint8*>(GetHandle()),
                     size.width(),
                     size.height(),
-                    x, y,
-                    x, y,
+                    x,
+                    y,
+                    x,
+                    y,
                     width,
                     height);
 
   // Copy the pixmap to the window.
-  XCopyArea(g_osmesa_display,
+  XCopyArea(xdisplay_,
             pixmap_,
             window_,
             window_graphics_context_,
-            x, y,
-            width, height,
-            x, y);
+            x,
+            y,
+            width,
+            height,
+            x,
+            y);
 
   return true;
 }
 
 NativeViewGLSurfaceOSMesa::~NativeViewGLSurfaceOSMesa() {
   Destroy();
 }
 
 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
     gfx::AcceleratedWidget window) {
@@ skipping 57 matching lines @@
     }
     case kGLImplementationMockGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace gfx