[Mac] Enable CrZombie for all processes.

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/browser/ui/cocoa/objc_zombie.h"
+#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/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #import "chrome/app/breakpad_mac.h"
-#import "chrome/browser/ui/cocoa/objc_method_swizzle.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!).
 @interface CrZombie {
   Class isa;
 }
 @end
 
 // Objects with enough space are made into "fat" zombies, which
@@ skipping 405 matching lines @@
 @implementation NSObject (CrZombie)
 
 - (BOOL)shouldBecomeCrZombie {
   return NO;
 }
 
 @end
 
 namespace ObjcEvilDoers {
 
-BOOL ZombieEnable(BOOL zombieAllObjects,
+bool ZombieEnable(bool zombieAllObjects,
                   size_t zombieCount) {
   // Only allow enable/disable on the main thread, just to keep things
   // simple.
   CHECK([NSThread isMainThread]);
 
   if (!ZombieInit())
-    return NO;
+    return false;
 
   g_zombieAllObjects = zombieAllObjects;
 
   // Replace the implementation of -[NSObject dealloc].
   Method m = class_getInstanceMethod([NSObject class], @selector(dealloc));
   if (!m)
-    return NO;
+    return false;
 
   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;
 
@@ skipping 10 matching lines @@
     g_zombies = NULL;
     if (g_zombieCount) {
       g_zombies =
           static_cast<ZombieRecord*>(calloc(g_zombieCount, sizeof(*g_zombies)));
       if (!g_zombies) {
         NOTREACHED();
         g_zombies = oldZombies;
         g_zombieCount = oldCount;
         g_zombieIndex = oldIndex;
         ZombieDisable();
-        return NO;
+        return false;
       }
     }
 
     // If the count is changing, allow some of the zombies to continue
     // shambling forward.
     const size_t sharedCount = std::min(oldCount, zombieCount);
     if (sharedCount) {
       // Get index of the first shared zombie.
       oldIndex = (oldIndex + oldCount - sharedCount) % oldCount;
 
       for (; g_zombieIndex < sharedCount; ++ g_zombieIndex) {
         DCHECK_LT(g_zombieIndex, g_zombieCount);
         DCHECK_LT(oldIndex, oldCount);
         std::swap(g_zombies[g_zombieIndex], oldZombies[oldIndex]);
         oldIndex = (oldIndex + 1) % oldCount;
       }
       g_zombieIndex %= g_zombieCount;
     }
   }
 
   // Free the old treadmill and any remaining zombies.
   if (oldZombies) {
     for (size_t i = 0; i < oldCount; ++i) {
       if (oldZombies[i].object)
         object_dispose(oldZombies[i].object);
     }
     free(oldZombies);
   }
 
-  return YES;
+  return true;
 }
 
 void ZombieDisable() {
   // Only allow enable/disable on the main thread, just to keep things
   // simple.
   CHECK([NSThread isMainThread]);
 
   // |ZombieInit()| was never called.
   if (!g_originalDeallocIMP)
     return;
@@ skipping 17 matching lines @@
   if (oldZombies) {
     for (size_t i = 0; i < oldCount; ++i) {
       if (oldZombies[i].object)
         object_dispose(oldZombies[i].object);
     }
     free(oldZombies);
   }
 }
 
 }  // namespace ObjcEvilDoers