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

media/audio/audio_output_controller.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 "media/audio/audio_output_controller.h"
 
 #include "base/message_loop.h"
 
 // Signal a pause in low-latency mode.
 static const int kPauseMark = -1;
@@ skipping 111 matching lines @@
 
 void AudioOutputController::SetVolume(double volume) {
   DCHECK(message_loop_);
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioOutputController::DoSetVolume, volume));
 }
 
 void AudioOutputController::EnqueueData(const uint8* data, uint32 size) {
   // Write data to the push source and ask for more data if needed.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   pending_request_ = false;
   // If |size| is set to 0, it indicates that the audio source doesn't have
   // more data right now, and so it doesn't make sense to send additional
   // request.
   if (size) {
     buffer_.Append(data, size);
     SubmitOnMoreData_Locked();
   }
 }
 
@@ skipping 28 matching lines @@
   stream_->SetVolume(volume_);
 
   // Finally set the state to kCreated.
   state_ = kCreated;
 
   // And then report we have been created.
   handler_->OnCreated(this);
 
   // If in normal latency mode then start buffering.
   if (!LowLatencyMode()) {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     SubmitOnMoreData_Locked();
   }
 }
 
 void AudioOutputController::DoPlay() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // We can start from created or paused state.
   if (state_ != kCreated && state_ != kPaused)
     return;
@@ skipping 81 matching lines @@
   DCHECK_EQ(message_loop_, MessageLoop::current());
   if (state_ != kClosed)
     handler_->OnError(this, code);
 }
 
 uint32 AudioOutputController::OnMoreData(
     AudioOutputStream* stream, uint8* dest,
     uint32 max_size, AudioBuffersState buffers_state) {
   // If regular latency mode is used.
   if (!sync_reader_) {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
 
     // Save current buffers state.
     buffers_state_ = buffers_state;
 
     if (state_ != kPlaying) {
       // Don't read anything. Save the number of bytes in the hardware buffer.
       return 0;
     }
 
     uint32 size = buffer_.Read(dest, max_size);
@@ skipping 24 matching lines @@
   if (pending_request_)
     return;
   pending_request_ = true;
 
   AudioBuffersState buffers_state = buffers_state_;
   buffers_state.pending_bytes += buffer_.forward_bytes();
 
   // If we need more data then call the event handler to ask for more data.
   // It is okay that we don't lock in this block because the parameters are
   // correct and in the worst case we are just asking more data than needed.
-  AutoUnlock auto_unlock(lock_);
+  base::AutoUnlock auto_unlock(lock_);
   handler_->OnMoreData(this, buffers_state);
 }
 
 }  // namespace media