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

chrome/browser/browser_thread.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 "chrome/browser/browser_thread.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/thread_restrictions.h"
 
@@ skipping 45 matching lines @@
   virtual bool BelongsToCurrentThread() {
     return BrowserThread::CurrentlyOn(id_);
   }
 
  private:
   BrowserThread::ID id_;
   DISALLOW_COPY_AND_ASSIGN(BrowserThreadMessageLoopProxy);
 };
 
 
-Lock BrowserThread::lock_;
+base::Lock BrowserThread::lock_;
 
 BrowserThread* BrowserThread::browser_threads_[ID_COUNT];
 
 BrowserThread::BrowserThread(BrowserThread::ID identifier)
     : Thread(browser_thread_names[identifier]),
       identifier_(identifier) {
   Initialize();
 }
 
 BrowserThread::BrowserThread(ID identifier, MessageLoop* message_loop)
     : Thread(message_loop->thread_name().c_str()),
       identifier_(identifier) {
   set_message_loop(message_loop);
   Initialize();
 }
 
 void BrowserThread::Initialize() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   DCHECK(identifier_ >= 0 && identifier_ < ID_COUNT);
   DCHECK(browser_threads_[identifier_] == NULL);
   browser_threads_[identifier_] = this;
 }
 
 BrowserThread::~BrowserThread() {
   // Stop the thread here, instead of the parent's class destructor.  This is so
   // that if there are pending tasks that run, code that checks that it's on the
   // correct BrowserThread succeeds.
   Stop();
 
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   browser_threads_[identifier_] = NULL;
 #ifndef NDEBUG
   // Double check that the threads are ordered correctly in the enumeration.
   for (int i = identifier_ + 1; i < ID_COUNT; ++i) {
     DCHECK(!browser_threads_[i]) <<
         "Threads must be listed in the reverse order that they die";
   }
 #endif
 }
 
 // static
 bool BrowserThread::IsWellKnownThread(ID identifier) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   return (identifier >= 0 && identifier < ID_COUNT &&
           browser_threads_[identifier]);
 }
 
 // static
 bool BrowserThread::CurrentlyOn(ID identifier) {
   // We shouldn't use MessageLoop::current() since it uses LazyInstance which
   // may be deleted by ~AtExitManager when a WorkerPool thread calls this
   // function.
   // http://crbug.com/63678
   base::ThreadRestrictions::ScopedAllowSingleton allow_singleton;
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   DCHECK(identifier >= 0 && identifier < ID_COUNT);
   return browser_threads_[identifier] &&
          browser_threads_[identifier]->message_loop() == MessageLoop::current();
 }
 
 // static
 bool BrowserThread::IsMessageLoopValid(ID identifier) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   DCHECK(identifier >= 0 && identifier < ID_COUNT);
   return browser_threads_[identifier] &&
          browser_threads_[identifier]->message_loop();
 }
 
 // static
 bool BrowserThread::PostTask(ID identifier,
                             const tracked_objects::Location& from_here,
                             Task* task) {
   return PostTaskHelper(identifier, from_here, task, 0, true);
@@ skipping 84 matching lines @@
     }
   } else {
     delete task;
   }
 
   if (!guaranteed_to_outlive_target_thread)
     lock_.Release();
 
   return !!message_loop;
 }