content: Remove 16 exit time destructors and 15 static initializers.

content/browser/renderer_host/render_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/renderer_host/render_process_host.h"
 
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/rand_util.h"
 #include "base/sys_info.h"
 #include "content/browser/browser_main.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/webui/web_ui_factory.h"
 #include "content/common/child_process_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
@@ skipping 57 matching lines @@
     return false;
 
   if (ChildProcessSecurityPolicy::GetInstance()->HasWebUIBindings(host->id()) !=
       content::WebUIFactory::Get()->HasWebUIScheme(site_url))
     return false;
 
   return content::GetContentClient()->browser()->IsSuitableHost(host, site_url);
 }
 
 // the global list of all renderer processes
-IDMap<RenderProcessHost> all_hosts;
+base::LazyInstance<IDMap<RenderProcessHost>,
+                   base::LeakyLazyInstanceTraits<IDMap<RenderProcessHost> > >
+    g_all_hosts(base::LINKER_INITIALIZED);
 
 }  // namespace
 
 // static
 bool RenderProcessHost::run_renderer_in_process_ = false;
 
 // static
 void RenderProcessHost::SetMaxRendererProcessCountForTest(size_t count) {
   max_renderer_count_override = count;
 }
 
 RenderProcessHost::RenderProcessHost(content::BrowserContext* browser_context)
     : max_page_id_(-1),
       fast_shutdown_started_(false),
       deleting_soon_(false),
       pending_views_(0),
       id_(ChildProcessInfo::GenerateChildProcessUniqueId()),
       browser_context_(browser_context),
       sudden_termination_allowed_(true),
       ignore_input_events_(false) {
   CHECK(!content::ExitedMainMessageLoop());
-  all_hosts.AddWithID(this, id());
-  all_hosts.set_check_on_null_data(true);
+  g_all_hosts.Get().AddWithID(this, id());
+  g_all_hosts.Get().set_check_on_null_data(true);
   // Initialize |child_process_activity_time_| to a reasonable value.
   mark_child_process_activity_time();
 }
 
 RenderProcessHost::~RenderProcessHost() {
   // In unit tests, Release() might not have been called.
-  if (all_hosts.Lookup(id()))
-    all_hosts.Remove(id());
+  if (g_all_hosts.Get().Lookup(id()))
+    g_all_hosts.Get().Remove(id());
 }
 
 bool RenderProcessHost::HasConnection() const {
   return channel_.get() != NULL;
 }
 
 void RenderProcessHost::Attach(IPC::Channel::Listener* listener,
                                int routing_id) {
   listeners_.AddWithID(listener, routing_id);
 }
@@ skipping 32 matching lines @@
     deleting_soon_ = true;
     // It's important not to wait for the DeleteTask to delete the channel
     // proxy. Kill it off now. That way, in case the profile is going away, the
     // rest of the objects attached to this RenderProcessHost start going
     // away first, since deleting the channel proxy will post a
     // OnChannelClosed() to IPC::ChannelProxy::Context on the IO thread.
     channel_.reset();
 
     // Remove ourself from the list of renderer processes so that we can't be
     // reused in between now and when the Delete task runs.
-    all_hosts.Remove(id());
+    g_all_hosts.Get().Remove(id());
   }
 }
 
 void RenderProcessHost::ReportExpectingClose(int32 listener_id) {
   listeners_expecting_close_.insert(listener_id);
 }
 
 void RenderProcessHost::AddPendingView() {
   pending_views_++;
 }
@@ skipping 10 matching lines @@
 
 bool RenderProcessHost::FastShutdownForPageCount(size_t count) {
   if (listeners_.size() == count)
     return FastShutdownIfPossible();
   return false;
 }
 
 // static
 RenderProcessHost::iterator RenderProcessHost::AllHostsIterator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return iterator(&all_hosts);
+  return iterator(g_all_hosts.Pointer());
 }
 
 // static
 RenderProcessHost* RenderProcessHost::FromID(int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return all_hosts.Lookup(render_process_id);
+  return g_all_hosts.Get().Lookup(render_process_id);
 }
 
 // static
 bool RenderProcessHost::ShouldTryToUseExistingProcessHost() {
-  size_t renderer_process_count = all_hosts.size();
+  size_t renderer_process_count = g_all_hosts.Get().size();
 
   // NOTE: Sometimes it's necessary to create more render processes than
   //       GetMaxRendererProcessCount(), for instance when we want to create
   //       a renderer process for a browser context that has no existing
   //       renderers. This is OK in moderation, since the
   //       GetMaxRendererProcessCount() is conservative.
 
   return run_renderer_in_process() ||
          (renderer_process_count >= GetMaxRendererProcessCount());
 }
 
 // static
 RenderProcessHost* RenderProcessHost::GetExistingProcessHost(
     content::BrowserContext* browser_context,
     const GURL& site_url) {
   // First figure out which existing renderers we can use.
   std::vector<RenderProcessHost*> suitable_renderers;
-  suitable_renderers.reserve(all_hosts.size());
+  suitable_renderers.reserve(g_all_hosts.Get().size());
 
   iterator iter(AllHostsIterator());
   while (!iter.IsAtEnd()) {
     if (run_renderer_in_process() ||
         IsSuitableHost(iter.GetCurrentValue(), browser_context, site_url))
       suitable_renderers.push_back(iter.GetCurrentValue());
 
     iter.Advance();
   }
 
   // Now pick a random suitable renderer, if we have any.
   if (!suitable_renderers.empty()) {
     int suitable_count = static_cast<int>(suitable_renderers.size());
     int random_index = base::RandInt(0, suitable_count - 1);
     return suitable_renderers[random_index];
   }
 
   return NULL;
 }