Disable child X window workaround when running in test harnesses that do

ui/gl/gl_surface_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/Xlib.h>
 }
 
 #include "ui/gl/gl_surface_glx.h"
 
@@ skipping 343 matching lines @@
   }
 
   typedef std::map<gfx::AcceleratedWidget, gfx::AcceleratedWidget> WindowMap;
   WindowMap child_to_parent_map_;
 
   DISALLOW_COPY_AND_ASSIGN(XExposeEventForwarder);
 };
 
 static base::LazyInstance<XExposeEventForwarder> g_xexpose_event_forwarder =
     LAZY_INSTANCE_INITIALIZER;
+
+// Do not use this workaround when running in test harnesses that do not have
+// a message loop or do not have a TYPE_GPU message loop.
+bool g_create_child_windows = false;
 #endif
 
 }  // namespace
 
 GLSurfaceGLX::GLSurfaceGLX() {}
 
 bool GLSurfaceGLX::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
   // http://crbug.com/245466
   setenv("force_s3tc_enable", "true", 1);
 
   // SGIVideoSyncProviderShim (if instantiated) will issue X commands on
   // it's own thread.
   XInitThreads();
 
 #if defined(TOOLKIT_GTK)
   // Be sure to use the X display handle and not the GTK display handle if this
   // is the GPU process.
-  if (base::MessageLoop::current()->type() == base::MessageLoop::TYPE_GPU)
+  g_create_child_windows =
+      base::MessageLoop::current() &&
+      base::MessageLoop::current()->type() == base::MessageLoop::TYPE_GPU;
+
+  if (g_create_child_windows)
     g_display = base::MessagePumpX11::GetDefaultXDisplay();
   else
     g_display = base::MessagePumpForUI::GetDefaultXDisplay();
 #else
   g_display = base::MessagePumpForUI::GetDefaultXDisplay();
 #endif
 
   if (!g_display) {
     LOG(ERROR) << "XOpenDisplay failed.";
     return false;
@@ skipping 72 matching lines @@
   AdjustBufferAllocation();
   return true;
 }
 
 void NativeViewGLSurfaceGLX::SetFrontbufferAllocation(bool allocated) {
   frontbuffer_allocated_ = allocated;
   AdjustBufferAllocation();
 }
 
 void NativeViewGLSurfaceGLX::AdjustBufferAllocation() {
+  if (!g_create_child_windows)
+    return;
+
   if (frontbuffer_allocated_ || backbuffer_allocated_)
     CreateChildWindow();
   else
     DestroyChildWindow();
 }
 
 void NativeViewGLSurfaceGLX::CreateChildWindow() {
+  DCHECK(g_create_child_windows);
+
   if (child_window_)
     return;
 
   XSetWindowAttributes set_window_attributes;
   set_window_attributes.event_mask = ExposureMask;
   child_window_ = XCreateWindow(
       g_display, parent_window_, 0, 0, size_.width(), size_.height(), 0,
       CopyFromParent, InputOutput, CopyFromParent, CWEventMask,
       &set_window_attributes);
   g_xexpose_event_forwarder.Pointer()->AddParentChildPair(
@@ skipping 21 matching lines @@
     child_window_(0),
     dummy_window_(0),
     backbuffer_allocated_(true),
     frontbuffer_allocated_(true),
 #endif
     config_(NULL) {
 }
 
 gfx::AcceleratedWidget NativeViewGLSurfaceGLX::GetDrawableHandle() const {
 #if defined(TOOLKIT_GTK)
-  if (child_window_)
-    return child_window_;
-  return dummy_window_;
-#else
+  if (g_create_child_windows) {
+    if (child_window_)
+      return child_window_;
+    return dummy_window_;
+  }
+#endif
   return parent_window_;
-#endif
 }
 
 bool NativeViewGLSurfaceGLX::Initialize() {
   XWindowAttributes attributes;
   if (!XGetWindowAttributes(g_display, parent_window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << parent_window_
         << ".";
     return false;
   }
   size_ = gfx::Size(attributes.width, attributes.height);
 
   gfx::AcceleratedWidget window_for_vsync = parent_window_;
 
 #if defined(TOOLKIT_GTK)
-  dummy_window_ = XCreateWindow(
-      g_display,
-      RootWindow(g_display, XScreenNumberOfScreen(attributes.screen)),
-      0, 0, 1, 1, 0, CopyFromParent, InputOutput, attributes.visual, 0, NULL);
-  window_for_vsync = dummy_window_;
-  CreateChildWindow();
+  if (g_create_child_windows) {
+    dummy_window_ = XCreateWindow(
+        g_display,
+        RootWindow(g_display, XScreenNumberOfScreen(attributes.screen)),
+        0, 0, 1, 1, 0, CopyFromParent, InputOutput, attributes.visual, 0, NULL);
+    window_for_vsync = dummy_window_;
+    CreateChildWindow();
+  }
 #endif
 
   if (g_glx_oml_sync_control_supported)
     vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_for_vsync));
   else if (g_glx_sgi_video_sync_supported)
     vsync_provider_.reset(new SGIVideoSyncVSyncProvider(window_for_vsync));
 
   return true;
 }
 
@@ skipping 213 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx