chrome: Remove 10 exit time destructors and 2 static initializers.

chrome/common/mac/objc_zombie.mm

 // 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.
 
 #import "chrome/common/mac/objc_zombie.h"
 
 #include <dlfcn.h>
 #include <execinfo.h>
 #include <mach-o/dyld.h>
 #include <mach-o/nlist.h>
 
 #import <objc/objc-class.h>
 
 #include <algorithm>
 #include <iostream>
 
 #include "base/debug/stack_trace.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/crash_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #import "chrome/common/mac/objc_method_swizzle.h"
 
 // Deallocated objects are re-classed as |CrZombie|.  No superclass
 // because then the class would have to override many/most of the
 // inherited methods (|NSObject| is like a category magnet!).
@@ skipping 40 matching lines @@
 // treadmill).
 Class g_zombieClass = Nil;  // cached [CrZombie class]
 Class g_fatZombieClass = Nil;  // cached [CrFatZombie class]
 size_t g_fatZombieSize = 0;
 
 // Whether to zombie all freed objects, or only those which return YES
 // from |-shouldBecomeCrZombie|.
 BOOL g_zombieAllObjects = NO;
 
 // Protects |g_zombieCount|, |g_zombieIndex|, and |g_zombies|.
-base::Lock lock_;
+base::LazyInstance<base::Lock, base::LeakyLazyInstanceTraits<base::Lock> >
+    g_lock = LAZY_INSTANCE_INITIALIZER;
 
 // How many zombies to keep before freeing, and the current head of
 // the circular buffer.
 size_t g_zombieCount = 0;
 size_t g_zombieIndex = 0;
 
 typedef struct {
   id object;   // The zombied object.
   Class wasa;  // Value of |object->isa| before we replaced it.
   void* trace[kBacktraceDepth];  // Backtrace at point of deallocation.
@@ skipping 117 matching lines @@
   }
 
   // The new record to swap into |g_zombies|.  If |g_zombieCount| is
   // zero, then |self| will be freed immediately.
   ZombieRecord zombieToFree = {self, wasa};
   zombieToFree.traceDepth =
       std::max(backtrace(zombieToFree.trace, kBacktraceDepth), 0);
 
   // Don't involve the lock when creating zombies without a treadmill.
   if (g_zombieCount > 0) {
-    base::AutoLock pin(lock_);
+    base::AutoLock pin(g_lock.Get());
 
     // Check the count again in a thread-safe manner.
     if (g_zombieCount > 0) {
       // Put the current object on the treadmill and keep the previous
       // occupant.
       std::swap(zombieToFree, g_zombies[g_zombieIndex]);
 
       // Bump the index forward.
       g_zombieIndex = (g_zombieIndex + 1) % g_zombieCount;
     }
   }
 
   // Do the free out here to prevent any chance of deadlock.
   if (zombieToFree.object)
     object_dispose(zombieToFree.object);
 }
 
 // Search the treadmill for |object| and fill in |*record| if found.
 // Returns YES if found.
 BOOL GetZombieRecord(id object, ZombieRecord* record) {
   // Holding the lock is reasonable because this should be fast, and
   // the process is going to crash presently anyhow.
-  base::AutoLock pin(lock_);
+  base::AutoLock pin(g_lock.Get());
   for (size_t i = 0; i < g_zombieCount; ++i) {
     if (g_zombies[i].object == object) {
       *record = g_zombies[i];
       return YES;
     }
   }
   return NO;
 }
 
 // Dump the symbols.  This is pulled out into a function to make it
@@ skipping 215 matching lines @@
   const IMP prevDeallocIMP = method_setImplementation(m, (IMP)ZombieDealloc);
   DCHECK(prevDeallocIMP == g_originalDeallocIMP ||
          prevDeallocIMP == (IMP)ZombieDealloc);
 
   // Grab the current set of zombies.  This is thread-safe because
   // only the main thread can change these.
   const size_t oldCount = g_zombieCount;
   ZombieRecord* oldZombies = g_zombies;
 
   {
-    base::AutoLock pin(lock_);
+    base::AutoLock pin(g_lock.Get());
 
     // Save the old index in case zombies need to be transferred.
     size_t oldIndex = g_zombieIndex;
 
     // Create the new zombie treadmill, disabling zombies in case of
     // failure.
     g_zombieIndex = 0;
     g_zombieCount = zombieCount;
     g_zombies = NULL;
     if (g_zombieCount) {
@@ skipping 50 matching lines @@
   // Put back the original implementation of -[NSObject dealloc].
   Method m = class_getInstanceMethod([NSObject class], @selector(dealloc));
   DCHECK(m);
   method_setImplementation(m, g_originalDeallocIMP);
 
   // Can safely grab this because it only happens on the main thread.
   const size_t oldCount = g_zombieCount;
   ZombieRecord* oldZombies = g_zombies;
 
   {
-    base::AutoLock pin(lock_);  // In case any |-dealloc| are in-progress.
+    base::AutoLock pin(g_lock.Get());  // In case any -dealloc are in progress.
     g_zombieCount = 0;
     g_zombies = NULL;
   }
 
   // Free any remaining zombies.
   if (oldZombies) {
     for (size_t i = 0; i < oldCount; ++i) {
       if (oldZombies[i].object)
         object_dispose(oldZombies[i].object);
     }
     free(oldZombies);
   }
 }
 
 }  // namespace ObjcEvilDoers