Remove static initializers from GpuProcessHost and GpuProcessHostUIShim.

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2011 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 "content/browser/gpu/gpu_process_host.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
+#include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_piece.h"
 #include "base/threading/thread.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu/gpu_data_manager.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
@@ skipping 19 matching lines @@
 enum GPUProcessLifetimeEvent {
   LAUNCHED,
   DIED_FIRST_TIME,
   DIED_SECOND_TIME,
   DIED_THIRD_TIME,
   DIED_FOURTH_TIME,
   GPU_PROCESS_LIFETIME_EVENT_MAX
 };
 
 // A global map from GPU process host ID to GpuProcessHost.
-static IDMap<GpuProcessHost> g_hosts_by_id;
+static base::LazyInstance<IDMap<GpuProcessHost> > g_hosts_by_id(
+    base::LINKER_INITIALIZED);
 
 // Number of times the gpu process has crashed in the current browser session.
 static int g_gpu_crash_count = 0;
 
 // Maximum number of times the gpu process is allowed to crash in a session.
 // Once this limit is reached, any request to launch the gpu process will fail.
 static const int kGpuMaxCrashCount = 3;
 
 int g_last_host_id = 0;
 
@@ skipping 111 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Don't grant further access to GPU if it is not allowed.
   GpuDataManager* gpu_data_manager = GpuDataManager::GetInstance();
   if (gpu_data_manager != NULL && !gpu_data_manager->GpuAccessAllowed())
     return NULL;
 
   // The current policy is to ignore the renderer ID and use a single GPU
   // process for all renderers. Later this will be extended to allow the
   // use of multiple GPU processes.
-  if (!g_hosts_by_id.IsEmpty()) {
-    IDMap<GpuProcessHost>::iterator it(&g_hosts_by_id);
+  if (!g_hosts_by_id.Pointer()->IsEmpty()) {
+    IDMap<GpuProcessHost>::iterator it(g_hosts_by_id.Pointer());
     return it.GetCurrentValue();
   }
 
   if (cause == content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH)
     return NULL;
 
   int host_id;
   host_id = ++g_last_host_id;
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLaunchCause",
@@ skipping 18 matching lines @@
             &SendGpuProcessMessage, renderer_id, cause, message));
 }
 
 // static
 GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_id == 0)
     return NULL;
 
-  return g_hosts_by_id.Lookup(host_id);
+  return g_hosts_by_id.Pointer()->Lookup(host_id);
 }
 
 GpuProcessHost::GpuProcessHost(int host_id)
     : BrowserChildProcessHost(GPU_PROCESS),
       host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
       in_process_(false) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU))
     in_process_ = true;
 
   // If the 'single GPU process' policy ever changes, we still want to maintain
   // it for 'gpu thread' mode and only create one instance of host and thread.
-  DCHECK(!in_process_ || g_hosts_by_id.IsEmpty());
+  DCHECK(!in_process_ || g_hosts_by_id.Pointer()->IsEmpty());
 
-  g_hosts_by_id.AddWithID(this, host_id_);
+  g_hosts_by_id.Pointer()->AddWithID(this, host_id_);
 
   // Post a task to create the corresponding GpuProcessHostUIShim.  The
   // GpuProcessHostUIShim will be destroyed if either the browser exits,
   // in which case it calls GpuProcessHostUIShim::DestroyAll, or the
   // GpuProcessHost is destroyed, which happens when the corresponding GPU
   // process terminates or fails to launch.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       NewRunnableFunction(&GpuProcessHostUIShim::Create, host_id));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   DCHECK(CalledOnValidThread());
 #if defined(OS_WIN)
   if (gpu_process_)
     CloseHandle(gpu_process_);
 #endif
 
   // In case we never started, clean up.
   while (!queued_messages_.empty()) {
     delete queued_messages_.front();
     queued_messages_.pop();
   }
 
-  g_hosts_by_id.Remove(host_id_);
+  g_hosts_by_id.Pointer()->Remove(host_id_);
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           NewRunnableFunction(GpuProcessHostUIShim::Destroy,
                                               host_id_));
 }
 
 bool GpuProcessHost::Init() {
   if (!CreateChannel())
     return false;
@@ skipping 330 matching lines @@
   scoped_ptr<EstablishChannelCallback> wrapped_callback(callback);
   wrapped_callback->Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     CreateCommandBufferCallback* callback, int32 route_id) {
   scoped_ptr<GpuProcessHost::CreateCommandBufferCallback>
     wrapped_callback(callback);
   callback->Run(route_id);
 }