Make the SandboxSymbolizeHelper Singleton Leaky and Enable Impacted Test

base/debug/stack_trace_posix.cc

 // Copyright (c) 2012 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/debug/stack_trace.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stddef.h>
@@ skipping 426 matching lines @@
   //             at ../sysdeps/x86_64/../ia64/backtrace.c:104
   // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
   //             at base/debug/stack_trace_posix.cc:175
   // #21 0x00000000007a4ae5 in
   //             base::(anonymous namespace)::StackDumpSignalHandler
   //             at base/process_util_posix.cc:172
   // #22 <signal handler called>
   StackTrace stack_trace;
 }
 
-}  // namespace
-
 #if defined(USE_SYMBOLIZE)
 
 // class SandboxSymbolizeHelper.
 //
 // The purpose of this class is to prepare and install a "file open" callback
 // needed by the stack trace symbolization code
 // (base/third_party/symbolize/symbolize.h) so that it can function properly
 // in a sandboxed process.  The caveat is that this class must be instantiated
 // before the sandboxing is enabled so that it can get the chance to open all
 // the object files that are loaded in the virtual address space of the current
 // process.
 class SandboxSymbolizeHelper {
  public:
   // Returns the singleton instance.
   static SandboxSymbolizeHelper* GetInstance() {
-    return Singleton<SandboxSymbolizeHelper>::get();
+    return Singleton<SandboxSymbolizeHelper,
+                     LeakySingletonTraits<SandboxSymbolizeHelper>>::get();
   }
 
  private:
   friend struct DefaultSingletonTraits<SandboxSymbolizeHelper>;
 
   SandboxSymbolizeHelper()
       : is_initialized_(false) {
     Init();
   }
 
@@ skipping 195 matching lines @@
 #endif  // !defined(OFFICIAL_BUILD)
 
   // Cache for the process memory regions.  Produced by parsing the contents
   // of /proc/self/maps cache.
   std::vector<MappedMemoryRegion> regions_;
 
   DISALLOW_COPY_AND_ASSIGN(SandboxSymbolizeHelper);
 };
 #endif  // USE_SYMBOLIZE
 
+}  // namespace
+
 bool EnableInProcessStackDumping() {
 #if defined(USE_SYMBOLIZE)
   SandboxSymbolizeHelper::GetInstance();
 #endif  // USE_SYMBOLIZE
 
   // When running in an application, our code typically expects SIGPIPE
   // to be ignored.  Therefore, when testing that same code, it should run
   // with SIGPIPE ignored as well.
   struct sigaction sigpipe_action;
   memset(&sigpipe_action, 0, sizeof(sigpipe_action));
@@ skipping 114 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base