Call GpuThread::Init before starting the GPU watchdog thread....

chrome/gpu/gpu_main.cc

 // Copyright (c) 2010 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 <stdlib.h>
 
 #include "app/app_switches.h"
 #include "app/gfx/gl/gl_context.h"
 #include "app/gfx/gl/gl_implementation.h"
 #include "base/environment.h"
@@ skipping 14 matching lines @@
 #include "chrome/app/breakpad_linux.h"
 #endif
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #endif
 
 #if defined(USE_X11)
 #include "app/x11_util.h"
 #include "app/x11_util_internal.h"
+#include "gfx/gtk_util.h"
 #endif
 
-
 namespace {
 
 // 1% per watchdog trial group.
 const int kFieldTrialSize = 1;
 
 // 5 - 20 seconds timeout.
 const int kMinGpuTimeout = 5;
 const int kMaxGpuTimeout = 20;
 
 #if defined(USE_X11)
@@ skipping 32 matching lines @@
   }
 
   MessageLoop main_message_loop(MessageLoop::TYPE_UI);
   PlatformThread::SetName("CrGpuMain");
 
 #if defined(OS_WIN)
   win_util::ScopedCOMInitializer com_initializer;
 #endif
 
 #if defined(USE_X11)
+  // The X11 port of the command buffer code assumes it can access the X
+  // display via the macro GDK_DISPLAY(), which implies that Gtk has been
+  // initialized. This code was taken from PluginThread. TODO(kbr):
+  // rethink whether initializing Gtk is really necessary or whether we
+  // should just send a raw display connection down to the GPUProcessor.
+  g_thread_init(NULL);
+  gfx::GtkInitFromCommandLine(command_line);
   SetGpuX11ErrorHandlers();
 #endif
 
-  // On Linux the GpuThread constructor performs certain
-  // initialization that is required before accessing the default X
-  // display.
+  // Load the GL implementation and locate the bindings before starting the GPU
+  // watchdog because this can take a lot of time and the GPU watchdog might
+  // terminate the GPU process.
+  if (!gfx::GLContext::InitializeOneOff())
+    return EXIT_FAILURE;
+
+  // Do this soon before running the message loop so accurate
+  // initialization time is recorded in the GPU info. Don't do it before
+  // starting the watchdog thread since it can take a significant amount of
+  // time to collect GPU information in GpuThread::Init.
   GpuProcess gpu_process;
   GpuThread* gpu_thread = new GpuThread;
+  gpu_thread->Init(start_time);
   gpu_process.set_main_thread(gpu_thread);
 
-  // Load the GL implementation and locate the bindings before starting as
-  // this can take a lot of time and the GPU watchdog might terminate the GPU
-  // process.
-  if (!gfx::GLContext::InitializeOneOff())
-    return EXIT_FAILURE;
-
   // Only enable this experimental feaure for a subset of users.
   scoped_refptr<base::FieldTrial> watchdog_trial(
       new base::FieldTrial("GpuWatchdogTrial", 100));
   int watchdog_timeout = 0;
   for (int i = kMinGpuTimeout; i <= kMaxGpuTimeout; ++i) {
     int group = watchdog_trial->AppendGroup(StringPrintf("%dsecs", i),
                                             kFieldTrialSize);
     if (group == watchdog_trial->group()) {
       watchdog_timeout = i;
       break;
     }
   }
 
-  scoped_ptr<base::Environment> env(base::Environment::Create());
-
   // In addition to disabling the watchdog if the command line switch is
   // present, disable it in two other cases. OSMesa is expected to run very
   // slowly.  Also disable the watchdog on valgrind because the code is expected
   // to run slowly in that case.
   bool enable_watchdog =
       watchdog_timeout != 0 &&
       !command_line.HasSwitch(switches::kDisableGpuWatchdog) &&
       gfx::GetGLImplementation() != gfx::kGLImplementationOSMesaGL &&
       !RunningOnValgrind();
 
   // Disable the watchdog in debug builds because they tend to only be run by
   // developers who will not appreciate the watchdog killing the GPU process.
 #ifndef NDEBUG
   enable_watchdog = false;
 #endif
 
+  // Start the GPU watchdog only after anything that is expected to be time
+  // consuming has completed, otherwise the process is liable to be aborted.
   scoped_refptr<GpuWatchdogThread> watchdog_thread;
   if (enable_watchdog) {
     watchdog_thread = new GpuWatchdogThread(MessageLoop::current(),
                                             watchdog_timeout * 1000);
     watchdog_thread->Start();
   }
 
-  // Do this immediately before running the message loop so the correct
-  // initialization time is recorded in the GPU info.
-  gpu_thread->Init(start_time);
-
   main_message_loop.Run();
 
   if (enable_watchdog)
     watchdog_thread->Stop();
 
   return 0;
 }