Add a new GetInstance() method for singleton classes used in chrome/browser files.

chrome/browser/child_process_launcher.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 "chrome/browser/child_process_launcher.h"
 
 #include <utility>  // For std::pair.
 
 #include "base/command_line.h"
 #include "base/lock.h"
@@ skipping 97 matching lines @@
     base::ProcessHandle handle = base::kNullProcessHandle;
 #if defined(OS_WIN)
     handle = sandbox::StartProcessWithAccess(cmd_line, exposed_dir);
 #elif defined(OS_POSIX)
 
 #if defined(OS_LINUX)
     if (use_zygote) {
       base::GlobalDescriptors::Mapping mapping;
       mapping.push_back(std::pair<uint32_t, int>(kPrimaryIPCChannel, ipcfd));
       const int crash_signal_fd =
-          Singleton<RendererCrashHandlerHostLinux>()->GetDeathSignalSocket();
+          RendererCrashHandlerHostLinux::GetInstance()->GetDeathSignalSocket();
       if (crash_signal_fd >= 0) {
         mapping.push_back(std::pair<uint32_t, int>(kCrashDumpSignal,
                                                    crash_signal_fd));
       }
-      handle = Singleton<ZygoteHost>()->ForkRenderer(cmd_line->argv(), mapping);
+      handle = ZygoteHost::GetInstance()->ForkRenderer(cmd_line->argv(),
+                                                       mapping);
     } else
     // Fall through to the normal posix case below when we're not zygoting.
 #endif
     {
       base::file_handle_mapping_vector fds_to_map;
       fds_to_map.push_back(std::make_pair(
           ipcfd,
           kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
 
 #if defined(OS_LINUX)
       // On Linux, we need to add some extra file descriptors for crash handling
       // and the sandbox.
       bool is_renderer =
           cmd_line->GetSwitchValueASCII(switches::kProcessType) ==
           switches::kRendererProcess;
       bool is_plugin =
           cmd_line->GetSwitchValueASCII(switches::kProcessType) ==
           switches::kPluginProcess;
 
       if (is_renderer || is_plugin) {
         int crash_signal_fd;
         if (is_renderer) {
-          crash_signal_fd = Singleton<RendererCrashHandlerHostLinux>()->
+          crash_signal_fd = RendererCrashHandlerHostLinux::GetInstance()->
               GetDeathSignalSocket();
         } else {
-          crash_signal_fd = Singleton<PluginCrashHandlerHostLinux>()->
+          crash_signal_fd = PluginCrashHandlerHostLinux::GetInstance()->
               GetDeathSignalSocket();
         }
         if (crash_signal_fd >= 0) {
           fds_to_map.push_back(std::make_pair(
               crash_signal_fd,
               kCrashDumpSignal + base::GlobalDescriptors::kBaseDescriptor));
         }
       }
       if (is_renderer) {
         const int sandbox_fd =
-            Singleton<RenderSandboxHostLinux>()->GetRendererSocket();
+            RenderSandboxHostLinux::GetInstance()->GetRendererSocket();
         fds_to_map.push_back(std::make_pair(
             sandbox_fd,
             kSandboxIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
       }
 #endif  // defined(OS_LINUX)
 
       bool launched = false;
 #if defined(OS_MACOSX)
       // It is possible for the child process to die immediately after
       // launching.  To prevent leaking MachBroker map entries in this case,
@@ skipping 75 matching lines @@
     base::Process process(handle);
      // Client has gone away, so just kill the process.  Using exit code 0
     // means that UMA won't treat this as a crash.
     process.Terminate(ResultCodes::NORMAL_EXIT);
     // On POSIX, we must additionally reap the child.
 #if defined(OS_POSIX)
 #if defined(OS_LINUX)
     if (zygote) {
       // If the renderer was created via a zygote, we have to proxy the reaping
       // through the zygote process.
-      Singleton<ZygoteHost>()->EnsureProcessTerminated(handle);
+      ZygoteHost::GetInstance()->EnsureProcessTerminated(handle);
     } else
 #endif  // OS_LINUX
     {
       ProcessWatcher::EnsureProcessTerminated(handle);
     }
 #endif  // OS_POSIX
     process.Close();
   }
 
   Client* client_;
@@ skipping 41 matching lines @@
 base::ProcessHandle ChildProcessLauncher::GetHandle() {
   DCHECK(!context_->starting_);
   return context_->process_.handle();
 }
 
 bool ChildProcessLauncher::DidProcessCrash() {
   bool did_crash, child_exited;
   base::ProcessHandle handle = context_->process_.handle();
 #if defined(OS_LINUX)
   if (context_->zygote_) {
-    did_crash = Singleton<ZygoteHost>()->DidProcessCrash(handle, &child_exited);
+    did_crash = ZygoteHost::GetInstance()->DidProcessCrash(handle,
+                                                           &child_exited);
   } else
 #endif
   {
     did_crash = base::DidProcessCrash(&child_exited, handle);
   }
 
   // POSIX: If the process crashed, then the kernel closed the socket for it
   // and so the child has already died by the time we get here. Since
   // DidProcessCrash called waitpid with WNOHANG, it'll reap the process.
   // However, if DidProcessCrash didn't reap the child, we'll need to in
   // Terminate via ProcessWatcher. So we can't close the handle here.
   if (child_exited)
     context_->process_.Close();
 
   return did_crash;
 }
 
 void ChildProcessLauncher::SetProcessBackgrounded(bool background) {
   DCHECK(!context_->starting_);
   context_->process_.SetProcessBackgrounded(background);
 }