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

base/tracked_objects.cc

 // 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.
 
 #include "base/tracked_objects.h"
 
 #include <math.h>
 
 #include "base/format_macros.h"
 #include "base/message_loop.h"
@@ skipping 67 matching lines @@
 Births::Births(const Location& location)
     : BirthOnThread(location),
       birth_count_(1) { }
 
 //------------------------------------------------------------------------------
 // ThreadData maintains the central data for all births and death.
 
 // static
 ThreadData* ThreadData::first_ = NULL;
 // static
-Lock ThreadData::list_lock_;
+base::Lock ThreadData::list_lock_;
 
 // static
 ThreadData::Status ThreadData::status_ = ThreadData::UNINITIALIZED;
 
 ThreadData::ThreadData() : next_(NULL) {
   // This shouldn't use the MessageLoop::current() LazyInstance since this might
   // be used on a non-joinable thread.
   // http://crbug.com/62728
   base::ThreadRestrictions::ScopedAllowSingleton scoped_allow_singleton;
   message_loop_ = MessageLoop::current();
 }
 
 ThreadData::~ThreadData() {}
 
 // static
 ThreadData* ThreadData::current() {
   if (!tls_index_.initialized())
     return NULL;
 
   ThreadData* registry = static_cast<ThreadData*>(tls_index_.Get());
   if (!registry) {
     // We have to create a new registry for ThreadData.
     bool too_late_to_create = false;
     {
       registry = new ThreadData;
-      AutoLock lock(list_lock_);
+      base::AutoLock lock(list_lock_);
       // Use lock to insure we have most recent status.
       if (!IsActive()) {
         too_late_to_create = true;
       } else {
         // Use lock to insert into list.
         registry->next_ = first_;
         first_ = registry;
       }
     }  // Release lock.
     if (too_late_to_create) {
@@ skipping 153 matching lines @@
 
   BirthMap::iterator it = birth_map_.find(location);
   if (it != birth_map_.end()) {
     it->second->RecordBirth();
     return it->second;
   }
 
   Births* tracker = new Births(location);
   // Lock since the map may get relocated now, and other threads sometimes
   // snapshot it (but they lock before copying it).
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   birth_map_[location] = tracker;
   return tracker;
 }
 
 void ThreadData::TallyADeath(const Births& lifetimes,
                              const TimeDelta& duration) {
   {
     // http://crbug.com/62728
     base::ThreadRestrictions::ScopedAllowSingleton scoped_allow_singleton;
     if (!message_loop_)  // In case message loop wasn't yet around...
       message_loop_ = MessageLoop::current();  // Find it now.
   }
 
   DeathMap::iterator it = death_map_.find(&lifetimes);
   if (it != death_map_.end()) {
     it->second.RecordDeath(duration);
     return;
   }
 
-  AutoLock lock(lock_);  // Lock since the map may get relocated now.
+  base::AutoLock lock(lock_);  // Lock since the map may get relocated now.
   death_map_[&lifetimes].RecordDeath(duration);
 }
 
 // static
 ThreadData* ThreadData::first() {
-  AutoLock lock(list_lock_);
+  base::AutoLock lock(list_lock_);
   return first_;
 }
 
 const std::string ThreadData::ThreadName() const {
   if (message_loop_)
     return message_loop_->thread_name();
   return "ThreadWithoutMessageLoop";
 }
 
 // This may be called from another thread.
 void ThreadData::SnapshotBirthMap(BirthMap *output) const {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (BirthMap::const_iterator it = birth_map_.begin();
        it != birth_map_.end(); ++it)
     (*output)[it->first] = it->second;
 }
 
 // This may be called from another thread.
 void ThreadData::SnapshotDeathMap(DeathMap *output) const {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (DeathMap::const_iterator it = death_map_.begin();
        it != death_map_.end(); ++it)
     (*output)[it->first] = it->second;
 }
 
 // static
 void ThreadData::ResetAllThreadData() {
   ThreadData* my_list = ThreadData::current()->first();
 
   for (ThreadData* thread_data = my_list;
        thread_data;
        thread_data = thread_data->next())
     thread_data->Reset();
 }
 
 void ThreadData::Reset() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (DeathMap::iterator it = death_map_.begin();
        it != death_map_.end(); ++it)
     it->second.Clear();
   for (BirthMap::iterator it = birth_map_.begin();
        it != birth_map_.end(); ++it)
     it->second->Clear();
 }
 
 #ifdef OS_WIN
 // A class used to count down which is accessed by several threads.  This is
 // used to make sure RunOnAllThreads() actually runs a task on the expected
 // count of threads.
 class ThreadData::ThreadSafeDownCounter {
  public:
   // Constructor sets the count, once and for all.
   explicit ThreadSafeDownCounter(size_t count);
 
   // Decrement the count, and return true if we hit zero.  Also delete this
   // instance automatically when we hit zero.
   bool LastCaller();
 
  private:
   size_t remaining_count_;
-  Lock lock_;  // protect access to remaining_count_.
+  base::Lock lock_;  // protect access to remaining_count_.
 };
 
 ThreadData::ThreadSafeDownCounter::ThreadSafeDownCounter(size_t count)
     : remaining_count_(count) {
   DCHECK_GT(remaining_count_, 0u);
 }
 
 bool ThreadData::ThreadSafeDownCounter::LastCaller() {
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     if (--remaining_count_)
       return false;
   }  // Release lock, so we can delete everything in this instance.
   delete this;
   return true;
 }
 
 // A Task class that runs a static method supplied, and checks to see if this
 // is the last tasks instance (on last thread) that will run the method.
 // IF this is the last run, then the supplied event is signalled.
@@ skipping 58 matching lines @@
 }
 #endif
 
 // static
 bool ThreadData::StartTracking(bool status) {
 #ifndef TRACK_ALL_TASK_OBJECTS
   return false;  // Not compiled in.
 #endif
 
   if (!status) {
-    AutoLock lock(list_lock_);
+    base::AutoLock lock(list_lock_);
     DCHECK(status_ == ACTIVE || status_ == SHUTDOWN);
     status_ = SHUTDOWN;
     return true;
   }
-  AutoLock lock(list_lock_);
+  base::AutoLock lock(list_lock_);
   DCHECK(status_ == UNINITIALIZED);
   CHECK(tls_index_.Initialize(NULL));
   status_ = ACTIVE;
   return true;
 }
 
 // static
 bool ThreadData::IsActive() {
   return status_ == ACTIVE;
 }
@@ skipping 17 matching lines @@
 }
 #endif
 
 // static
 void ThreadData::ShutdownSingleThreadedCleanup() {
   // We must be single threaded... but be careful anyway.
   if (!StartTracking(false))
     return;
   ThreadData* thread_data_list;
   {
-    AutoLock lock(list_lock_);
+    base::AutoLock lock(list_lock_);
     thread_data_list = first_;
     first_ = NULL;
   }
 
   while (thread_data_list) {
     ThreadData* next_thread_data = thread_data_list;
     thread_data_list = thread_data_list->next();
 
     for (BirthMap::iterator it = next_thread_data->birth_map_.begin();
          next_thread_data->birth_map_.end() != it; ++it)
@@ skipping 89 matching lines @@
 }
 
 void DataCollector::Append(const ThreadData& thread_data) {
   // Get copy of data (which is done under ThreadData's lock).
   ThreadData::BirthMap birth_map;
   thread_data.SnapshotBirthMap(&birth_map);
   ThreadData::DeathMap death_map;
   thread_data.SnapshotDeathMap(&death_map);
 
   // Use our lock to protect our accumulation activity.
-  AutoLock lock(accumulation_lock_);
+  base::AutoLock lock(accumulation_lock_);
 
   DCHECK(count_of_contributing_threads_);
 
   for (ThreadData::DeathMap::const_iterator it = death_map.begin();
        it != death_map.end(); ++it) {
     collection_.push_back(Snapshot(*it->first, thread_data, it->second));
     global_birth_count_[it->first] -= it->first->birth_count();
   }
 
   for (ThreadData::BirthMap::const_iterator it = birth_map.begin();
@@ skipping 420 matching lines @@
                         (combined_selectors_ & BIRTH_THREAD) ? "*" :
                           sample.birth().birth_thread()->ThreadName().c_str(),
                         (combined_selectors_ & DEATH_THREAD) ? "*" :
                           sample.DeathThreadName().c_str());
   sample.birth().location().Write(!(combined_selectors_ & BIRTH_FILE),
                                   !(combined_selectors_ & BIRTH_FUNCTION),
                                   output);
 }
 
 }  // namespace tracked_objects