Replace TestLaucher non-leaky LazyInstances with a static pointers.

base/test/launcher/test_launcher.cc

 // Copyright 2013 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 "base/test/launcher/test_launcher.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 79 matching lines @@
 // Avoids flooding the logs with amount of output that gums up
 // the infrastructure.
 const size_t kOutputSnippetLinesLimit = 5000;
 
 // Limit of output snippet size. Exceeding this limit
 // results in truncating the output and failing the test.
 const size_t kOutputSnippetBytesLimit = 300 * 1024;
 
 // Set of live launch test processes with corresponding lock (it is allowed
 // for callers to launch processes on different threads).
-LazyInstance<std::map<ProcessHandle, CommandLine>>::DestructorAtExit
-    g_live_processes = LAZY_INSTANCE_INITIALIZER;
-LazyInstance<Lock>::DestructorAtExit g_live_processes_lock =
-    LAZY_INSTANCE_INITIALIZER;
+Lock* GetLiveProcessesLock() {
+  static auto* lock = new Lock;
+  return lock;
+}
+
+std::map<ProcessHandle, CommandLine>* GetLiveProcesses() {
+  static auto* map = new std::map<ProcessHandle, CommandLine>;
+  return map;
+}
 
 // Performance trace generator.
-LazyInstance<TestLauncherTracer>::DestructorAtExit g_tracer =
-    LAZY_INSTANCE_INITIALIZER;
+TestLauncherTracer* GetTestLauncherTracer() {
+  static auto* tracer = new TestLauncherTracer;
+  return tracer;
+}
 
 #if defined(OS_POSIX)
 // Self-pipe that makes it possible to do complex shutdown handling
 // outside of the signal handler.
 int g_shutdown_pipe[2] = { -1, -1 };
 
 void ShutdownPipeSignalHandler(int signal) {
   HANDLE_EINTR(write(g_shutdown_pipe[1], "q", 1));
 }
 
 void KillSpawnedTestProcesses() {
   // Keep the lock until exiting the process to prevent further processes
   // from being spawned.
-  AutoLock lock(g_live_processes_lock.Get());
+  AutoLock lock(*GetLiveProcessesLock());
 
-  fprintf(stdout,
-          "Sending SIGTERM to %" PRIuS " child processes... ",
-          g_live_processes.Get().size());
+  fprintf(stdout, "Sending SIGTERM to %" PRIuS " child processes... ",
+          GetLiveProcesses()->size());
   fflush(stdout);
 
-  for (std::map<ProcessHandle, CommandLine>::iterator i =
-           g_live_processes.Get().begin();
-       i != g_live_processes.Get().end();
-       ++i) {
+  for (const auto& pair : *GetLiveProcesses()) {
     // Send the signal to entire process group.
-    kill((-1) * (i->first), SIGTERM);
+    kill((-1) * (pair.first), SIGTERM);
   }
 
   fprintf(stdout,
           "done.\nGiving processes a chance to terminate cleanly... ");
   fflush(stdout);
 
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(500));
 
   fprintf(stdout, "done.\n");
   fflush(stdout);
 
-  fprintf(stdout,
-          "Sending SIGKILL to %" PRIuS " child processes... ",
-          g_live_processes.Get().size());
+  fprintf(stdout, "Sending SIGKILL to %" PRIuS " child processes... ",
+          GetLiveProcesses()->size());
   fflush(stdout);
 
-  for (std::map<ProcessHandle, CommandLine>::iterator i =
-           g_live_processes.Get().begin();
-       i != g_live_processes.Get().end();
-       ++i) {
+  for (const auto& pair : *GetLiveProcesses()) {
     // Send the signal to entire process group.
-    kill((-1) * (i->first), SIGKILL);
+    kill((-1) * (pair.first), SIGKILL);
   }
 
   fprintf(stdout, "done.\n");
   fflush(stdout);
 }
 
 // I/O watcher for the reading end of the self-pipe above.
 // Terminates any launched child processes and exits the process.
 void OnShutdownPipeReadable() {
   fprintf(stdout, "\nCaught signal. Killing spawned test processes...\n");
@@ skipping 136 matching lines @@
   // new child will be privileged and trusted.
   new_options.allow_new_privs = true;
 #endif
 
   Process process;
 
   {
     // Note how we grab the lock before the process possibly gets created.
     // This ensures that when the lock is held, ALL the processes are registered
     // in the set.
-    AutoLock lock(g_live_processes_lock.Get());
+    AutoLock lock(*GetLiveProcessesLock());
 
 #if defined(OS_WIN)
     // Allow the handle used to capture stdio and stdout to be inherited by the
-    // child. Note that this is done under g_live_processes_lock to ensure that
+    // child. Note that this is done under GetLiveProcessesLock() to ensure that
     // only the desired child receives the handle.
     if (new_options.stdout_handle) {
       ::SetHandleInformation(new_options.stdout_handle, HANDLE_FLAG_INHERIT,
                              HANDLE_FLAG_INHERIT);
     }
 #endif
 
     process = LaunchProcess(command_line, new_options);
 
 #if defined(OS_WIN)
     // Revoke inheritance so that the handle isn't leaked into other children.
-    // Note that this is done under g_live_processes_lock to ensure that only
+    // Note that this is done under GetLiveProcessesLock() to ensure that only
     // the desired child receives the handle.
     if (new_options.stdout_handle)
       ::SetHandleInformation(new_options.stdout_handle, HANDLE_FLAG_INHERIT, 0);
 #endif
 
     if (!process.IsValid())
       return -1;
 
     // TODO(rvargas) crbug.com/417532: Don't store process handles.
-    g_live_processes.Get().insert(std::make_pair(process.Handle(),
-                                                 command_line));
+    GetLiveProcesses()->insert(std::make_pair(process.Handle(), command_line));
   }
 
   if (!launched_callback.is_null())
     launched_callback.Run(process.Handle(), process.Pid());
 
   int exit_code = 0;
   if (!process.WaitForExitWithTimeout(timeout, &exit_code)) {
     *was_timeout = true;
     exit_code = -1;  // Set a non-zero exit code to signal a failure.
 
     // Ensure that the process terminates.
     process.Terminate(-1, true);
   }
 
   {
     // Note how we grab the log before issuing a possibly broad process kill.
     // Other code parts that grab the log kill processes, so avoid trying
     // to do that twice and trigger all kinds of log messages.
-    AutoLock lock(g_live_processes_lock.Get());
+    AutoLock lock(*GetLiveProcessesLock());
 
 #if defined(OS_POSIX)
     if (exit_code != 0) {
       // On POSIX, in case the test does not exit cleanly, either due to a crash
       // or due to it timing out, we need to clean up any child processes that
       // it might have created. On Windows, child processes are automatically
       // cleaned up using JobObjects.
       KillProcessGroup(process.Handle());
     }
 #endif
 
-    g_live_processes.Get().erase(process.Handle());
+    GetLiveProcesses()->erase(process.Handle());
   }
 
-  g_tracer.Get().RecordProcessExecution(start_time,
-                                        TimeTicks::Now() - start_time);
+  GetTestLauncherTracer()->RecordProcessExecution(
+      start_time, TimeTicks::Now() - start_time);
 
   return exit_code;
 }
 
 void RunCallback(const TestLauncher::GTestProcessCompletedCallback& callback,
                  int exit_code,
                  const TimeDelta& elapsed_time,
                  bool was_timeout,
                  const std::string& output) {
   callback.Run(exit_code, elapsed_time, was_timeout, output);
@@ skipping 722 matching lines @@
   if (command_line->HasSwitch(switches::kTestLauncherSummaryOutput)) {
     FilePath summary_path(command_line->GetSwitchValuePath(
                               switches::kTestLauncherSummaryOutput));
     if (!results_tracker_.SaveSummaryAsJSON(summary_path, additional_tags)) {
       LOG(ERROR) << "Failed to save test launcher output summary.";
     }
   }
   if (command_line->HasSwitch(switches::kTestLauncherTrace)) {
     FilePath trace_path(
         command_line->GetSwitchValuePath(switches::kTestLauncherTrace));
-    if (!g_tracer.Get().Dump(trace_path)) {
+    if (!GetTestLauncherTracer()->Dump(trace_path)) {
       LOG(ERROR) << "Failed to save test launcher trace.";
     }
   }
 }
 
 void TestLauncher::OnLaunchTestProcessFinished(
     const GTestProcessCompletedCallback& callback,
     int exit_code,
     const TimeDelta& elapsed_time,
     bool was_timeout,
@@ skipping 24 matching lines @@
   results_tracker_.PrintSummaryOfCurrentIteration();
 
   // Kick off the next iteration.
   ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&TestLauncher::RunTestIteration, Unretained(this)));
 }
 
 void TestLauncher::OnOutputTimeout() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  AutoLock lock(g_live_processes_lock.Get());
+  AutoLock lock(*GetLiveProcessesLock());
 
   fprintf(stdout, "Still waiting for the following processes to finish:\n");
 
-  for (std::map<ProcessHandle, CommandLine>::iterator i =
-           g_live_processes.Get().begin();
-       i != g_live_processes.Get().end();
-       ++i) {
+  for (const auto& pair : *GetLiveProcesses()) {
 #if defined(OS_WIN)
-    fwprintf(stdout, L"\t%s\n", i->second.GetCommandLineString().c_str());
+    fwprintf(stdout, L"\t%s\n", pair.second.GetCommandLineString().c_str());
 #else
-    fprintf(stdout, "\t%s\n", i->second.GetCommandLineString().c_str());
+    fprintf(stdout, "\t%s\n", pair.second.GetCommandLineString().c_str());
 #endif
   }
 
   fflush(stdout);
 
   // Arm the timer again - otherwise it would fire only once.
   watchdog_timer_.Reset();
 }
 
 scoped_refptr<TaskRunner> TestLauncher::GetTaskRunner() {
@@ skipping 32 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base