Upating the app, ceee, chrome, ipc, media, and net directories to use the correct lock.h file.

chrome/browser/ui/cocoa/objc_zombie.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/objc_zombie.h"
 
 #include <dlfcn.h>
 #include <mach-o/dyld.h>
 #include <mach-o/nlist.h>
 
 #import <objc/objc-class.h>
 
-#include "base/lock.h"
 #include "base/logging.h"
+#include "base/synchronization/lock.h"
 #import "chrome/app/breakpad_mac.h"
 #import "chrome/browser/ui/cocoa/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
@@ skipping 24 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|.
-Lock lock_;
+base::Lock lock_;
 
 // 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.
 } ZombieRecord;
@@ skipping 70 matching lines @@
   } else {
     self->isa = g_zombieClass;
   }
 
   // The new record to swap into |g_zombies|.  If |g_zombieCount| is
   // zero, then |self| will be freed immediately.
   ZombieRecord zombieToFree = {self, wasa};
 
   // Don't involve the lock when creating zombies without a treadmill.
   if (g_zombieCount > 0) {
-    AutoLock pin(lock_);
+    base::AutoLock pin(lock_);
 
     // 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)
     free(zombieToFree.object);
 }
 
 // Attempt to determine the original class of zombie |object|.
 Class ZombieWasa(id object) {
   // Fat zombies can hold onto their |wasa| past the point where the
   // object was actually freed.  Note that to arrive here at all,
   // |object|'s memory must still be accessible.
   if (object_getClass(object) == g_fatZombieClass)
     return static_cast<CrFatZombie*>(object)->wasa;
 
   // For instances which weren't big enough to store |wasa|, check if
   // the object is still on the treadmill.
-  AutoLock pin(lock_);
+  base::AutoLock pin(lock_);
   for (size_t i=0; i < g_zombieCount; ++i) {
     if (g_zombies[i].object == object)
       return g_zombies[i].wasa;
   }
 
   return Nil;
 }
 
 // Log a message to a freed object.  |wasa| is the object's original
 // class.  |aSelector| is the selector which the calling code was
@@ skipping 129 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;
 
   {
-    AutoLock pin(lock_);
+    base::AutoLock pin(lock_);
 
     // 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));
   CHECK(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;
 
   {
-    AutoLock pin(lock_);  // In case any |-dealloc| are in-progress.
+    base::AutoLock pin(lock_);  // 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)
         free(oldZombies[i].object);
     }
     free(oldZombies);
   }
 }
 
 }  // namespace ObjcEvilDoers