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

ipc/ipc_sync_channel.cc

 // Copyright (c) 2006-2008 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 "ipc/ipc_sync_channel.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_local.h"
@@ skipping 37 matching lines @@
       ReceivedSyncMsgQueue::lazy_tls_ptr_.Pointer()->Set(rv);
     }
     rv->listener_count_++;
     return rv;
   }
 
   // Called on IPC thread when a synchronous message or reply arrives.
   void QueueMessage(const Message& msg, SyncChannel::SyncContext* context) {
     bool was_task_pending;
     {
-      AutoLock auto_lock(message_lock_);
+      base::AutoLock auto_lock(message_lock_);
 
       was_task_pending = task_pending_;
       task_pending_ = true;
 
       // We set the event in case the listener thread is blocked (or is about
       // to). In case it's not, the PostTask dispatches the messages.
       message_queue_.push_back(QueuedMessage(new Message(msg), context));
     }
 
     dispatch_event_.Signal();
     if (!was_task_pending) {
       listener_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
           this, &ReceivedSyncMsgQueue::DispatchMessagesTask));
     }
   }
 
   void QueueReply(const Message &msg, SyncChannel::SyncContext* context) {
     received_replies_.push_back(QueuedMessage(new Message(msg), context));
   }
 
   // Called on the listener's thread to process any queues synchronous
   // messages.
   void DispatchMessagesTask() {
     {
-      AutoLock auto_lock(message_lock_);
+      base::AutoLock auto_lock(message_lock_);
       task_pending_ = false;
     }
     DispatchMessages();
   }
 
   void DispatchMessages() {
     while (true) {
       Message* message;
       scoped_refptr<SyncChannel::SyncContext> context;
       {
-        AutoLock auto_lock(message_lock_);
+        base::AutoLock auto_lock(message_lock_);
         if (message_queue_.empty())
           break;
 
         message = message_queue_.front().message;
         context = message_queue_.front().context;
         message_queue_.pop_front();
       }
 
       context->OnDispatchMessage(*message);
       delete message;
     }
   }
 
   // SyncChannel calls this in its destructor.
   void RemoveContext(SyncContext* context) {
-    AutoLock auto_lock(message_lock_);
+    base::AutoLock auto_lock(message_lock_);
 
     SyncMessageQueue::iterator iter = message_queue_.begin();
     while (iter != message_queue_.end()) {
       if (iter->context == context) {
         delete iter->message;
         iter = message_queue_.erase(iter);
       } else {
         iter++;
       }
     }
@@ skipping 57 matching lines @@
   typedef std::deque<QueuedMessage> SyncMessageQueue;
   SyncMessageQueue message_queue_;
 
   std::vector<QueuedMessage> received_replies_;
 
   // Set when we got a synchronous message that we must respond to as the
   // sender needs its reply before it can reply to our original synchronous
   // message.
   WaitableEvent dispatch_event_;
   MessageLoop* listener_message_loop_;
-  Lock message_lock_;
+  base::Lock message_lock_;
   bool task_pending_;
   int listener_count_;
 
   // The current send done event watcher for this thread. Used to maintain
   // a local global stack of send done watchers to ensure that nested sync
   // message loops complete correctly.
   base::WaitableEventWatcher* top_send_done_watcher_;
 };
 
 base::LazyInstance<base::ThreadLocalPointer<SyncChannel::ReceivedSyncMsgQueue> >
@@ skipping 17 matching lines @@
 // we know how to deserialize the reply.  Returns a handle that's set when
 // the reply has arrived.
 void SyncChannel::SyncContext::Push(SyncMessage* sync_msg) {
   // The event is created as manual reset because in between Signal and
   // OnObjectSignalled, another Send can happen which would stop the watcher
   // from being called.  The event would get watched later, when the nested
   // Send completes, so the event will need to remain set.
   PendingSyncMsg pending(SyncMessage::GetMessageId(*sync_msg),
                          sync_msg->GetReplyDeserializer(),
                          new WaitableEvent(true, false));
-  AutoLock auto_lock(deserializers_lock_);
+  base::AutoLock auto_lock(deserializers_lock_);
   deserializers_.push_back(pending);
 }
 
 bool SyncChannel::SyncContext::Pop() {
   bool result;
   {
-    AutoLock auto_lock(deserializers_lock_);
+    base::AutoLock auto_lock(deserializers_lock_);
     PendingSyncMsg msg = deserializers_.back();
     delete msg.deserializer;
     delete msg.done_event;
     msg.done_event = NULL;
     deserializers_.pop_back();
     result = msg.send_result;
   }
 
   // We got a reply to a synchronous Send() call that's blocking the listener
   // thread.  However, further down the call stack there could be another
   // blocking Send() call, whose reply we received after we made this last
   // Send() call.  So check if we have any queued replies available that
   // can now unblock the listener thread.
   ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       received_sync_msgs_.get(), &ReceivedSyncMsgQueue::DispatchReplies));
 
   return result;
 }
 
 WaitableEvent* SyncChannel::SyncContext::GetSendDoneEvent() {
-  AutoLock auto_lock(deserializers_lock_);
+  base::AutoLock auto_lock(deserializers_lock_);
   return deserializers_.back().done_event;
 }
 
 WaitableEvent* SyncChannel::SyncContext::GetDispatchEvent() {
   return received_sync_msgs_->dispatch_event();
 }
 
 void SyncChannel::SyncContext::DispatchMessages() {
   received_sync_msgs_->DispatchMessages();
 }
 
 bool SyncChannel::SyncContext::TryToUnblockListener(const Message* msg) {
-  AutoLock auto_lock(deserializers_lock_);
+  base::AutoLock auto_lock(deserializers_lock_);
   if (deserializers_.empty() ||
       !SyncMessage::IsMessageReplyTo(*msg, deserializers_.back().id)) {
     return false;
   }
 
   if (!msg->is_reply_error()) {
     deserializers_.back().send_result = deserializers_.back().deserializer->
         SerializeOutputParameters(*msg);
   }
   deserializers_.back().done_event->Signal();
@@ skipping 39 matching lines @@
   Context::OnChannelOpened();
 }
 
 void SyncChannel::SyncContext::OnChannelClosed() {
   CancelPendingSends();
   shutdown_watcher_.StopWatching();
   Context::OnChannelClosed();
 }
 
 void SyncChannel::SyncContext::OnSendTimeout(int message_id) {
-  AutoLock auto_lock(deserializers_lock_);
+  base::AutoLock auto_lock(deserializers_lock_);
   PendingSyncMessageQueue::iterator iter;
   for (iter = deserializers_.begin(); iter != deserializers_.end(); iter++) {
     if (iter->id == message_id) {
       iter->done_event->Signal();
       break;
     }
   }
 }
 
 void SyncChannel::SyncContext::CancelPendingSends() {
-  AutoLock auto_lock(deserializers_lock_);
+  base::AutoLock auto_lock(deserializers_lock_);
   PendingSyncMessageQueue::iterator iter;
   for (iter = deserializers_.begin(); iter != deserializers_.end(); iter++)
     iter->done_event->Signal();
 }
 
 void SyncChannel::SyncContext::OnWaitableEventSignaled(WaitableEvent* event) {
   if (event == shutdown_event_) {
     // Process shut down before we can get a reply to a synchronous message.
     // Cancel pending Send calls, which will end up setting the send done event.
     CancelPendingSends();
@@ skipping 136 matching lines @@
 void SyncChannel::OnWaitableEventSignaled(WaitableEvent* event) {
   DCHECK(event == sync_context()->GetDispatchEvent());
   // The call to DispatchMessages might delete this object, so reregister
   // the object watcher first.
   event->Reset();
   dispatch_watcher_.StartWatching(event, this);
   sync_context()->DispatchMessages();
 }
 
 }  // namespace IPC