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

chrome/renderer/media/audio_renderer_impl.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/renderer/media/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include "chrome/common/render_messages_params.h"
 #include "chrome/renderer/audio_message_filter.h"
@@ skipping 53 matching lines @@
   // Calculate the number of bytes per second using information of the stream.
   bytes_per_second_ = params_.sample_rate * params_.channels *
       params_.bits_per_sample / 8;
 
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererImpl::CreateStreamTask, params_));
   return true;
 }
 
 void AudioRendererImpl::OnStop() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
   stopped_ = true;
 
   // We should never touch |io_loop_| after being stopped, so post our final
   // task to clean up.
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererImpl::DestroyTask));
 }
 
 void AudioRendererImpl::ConsumeAudioSamples(
     scoped_refptr<media::Buffer> buffer_in) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   // TODO(hclam): handle end of stream here.
 
   // Use the base class to queue the buffer.
   AudioRendererBase::ConsumeAudioSamples(buffer_in);
 
   // Post a task to render thread to notify a packet reception.
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererImpl::NotifyPacketReadyTask));
 }
 
 void AudioRendererImpl::SetPlaybackRate(float rate) {
   DCHECK(rate >= 0.0f);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   // Handle the case where we stopped due to |io_loop_| dying.
   if (stopped_) {
     AudioRendererBase::SetPlaybackRate(rate);
     return;
   }
 
   // We have two cases here:
   // Play: GetPlaybackRate() == 0.0 && rate != 0.0
   // Pause: GetPlaybackRate() != 0.0 && rate == 0.0
   if (GetPlaybackRate() == 0.0f && rate != 0.0f) {
@@ skipping 10 matching lines @@
   // the previous packet request may be stalled by a pause.
   if (rate > 0.0f) {
     io_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &AudioRendererImpl::NotifyPacketReadyTask));
   }
 }
 
 void AudioRendererImpl::Pause(media::FilterCallback* callback) {
   AudioRendererBase::Pause(callback);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererImpl::PauseTask));
 }
 
 void AudioRendererImpl::Seek(base::TimeDelta time,
                              media::FilterCallback* callback) {
   AudioRendererBase::Seek(time, callback);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererImpl::SeekTask));
 }
 
 
 void AudioRendererImpl::Play(media::FilterCallback* callback) {
   AudioRendererBase::Play(callback);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   if (GetPlaybackRate() != 0.0f) {
     io_loop_->PostTask(FROM_HERE,
                        NewRunnableMethod(this, &AudioRendererImpl::PlayTask));
   } else {
     io_loop_->PostTask(FROM_HERE,
                        NewRunnableMethod(this, &AudioRendererImpl::PauseTask));
   }
 }
 
 void AudioRendererImpl::SetVolume(float volume) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(
           this, &AudioRendererImpl::SetVolumeTask, volume));
 }
 
 void AudioRendererImpl::OnCreated(base::SharedMemoryHandle handle,
                                   uint32 length) {
   DCHECK(MessageLoop::current() == io_loop_);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   shared_memory_.reset(new base::SharedMemory(handle, false));
   shared_memory_->Map(length);
   shared_memory_size_ = length;
 }
 
 void AudioRendererImpl::OnLowLatencyCreated(base::SharedMemoryHandle,
                                             base::SyncSocket::Handle, uint32) {
   // AudioRenderer should not have a low-latency audio channel.
   NOTREACHED();
 }
 
 void AudioRendererImpl::OnRequestPacket(AudioBuffersState buffers_state) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     DCHECK(!pending_request_);
     pending_request_ = true;
     request_buffers_state_ = buffers_state;
   }
 
   // Try to fill in the fulfill the packet request.
   NotifyPacketReadyTask();
 }
 
 void AudioRendererImpl::OnStateChanged(
     const ViewMsg_AudioStreamState_Params& state) {
   DCHECK(MessageLoop::current() == io_loop_);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   switch (state.state) {
     case ViewMsg_AudioStreamState_Params::kError:
       // We receive this error if we counter an hardware error on the browser
       // side. We can proceed with ignoring the audio stream.
       // TODO(hclam): We need more handling of these kind of error. For example
       // re-try creating the audio output stream on the browser side or fail
       // nicely and report to demuxer that the whole audio stream is discarded.
@@ skipping 10 matching lines @@
 }
 
 void AudioRendererImpl::OnVolume(double volume) {
   // TODO(hclam): decide whether we need to report the current volume to
   // pipeline.
 }
 
 void AudioRendererImpl::CreateStreamTask(AudioParameters audio_params) {
   DCHECK(MessageLoop::current() == io_loop_);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   // Make sure we don't call create more than once.
   DCHECK_EQ(0, stream_id_);
   stream_id_ = filter_->AddDelegate(this);
   io_loop_->AddDestructionObserver(this);
 
   ViewHostMsg_Audio_CreateStream_Params params;
   params.params = audio_params;
@@ skipping 32 matching lines @@
   DCHECK_NE(0, stream_id_);
   filter_->RemoveDelegate(stream_id_);
   filter_->Send(new ViewHostMsg_CloseAudioStream(0, stream_id_));
   io_loop_->RemoveDestructionObserver(this);
   stream_id_ = 0;
 }
 
 void AudioRendererImpl::SetVolumeTask(double volume) {
   DCHECK(MessageLoop::current() == io_loop_);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
   filter_->Send(new ViewHostMsg_SetAudioVolume(0, stream_id_, volume));
 }
 
 void AudioRendererImpl::NotifyPacketReadyTask() {
   DCHECK(MessageLoop::current() == io_loop_);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
   if (pending_request_ && GetPlaybackRate() > 0.0f) {
     DCHECK(shared_memory_.get());
 
     // Adjust the playback delay.
     base::Time current_time = base::Time::Now();
 
     base::TimeDelta request_delay =
         ConvertToDuration(request_buffers_state_.total_bytes());
@@ skipping 25 matching lines @@
     // Then tell browser process we are done filling into the buffer.
     filter_->Send(
         new ViewHostMsg_NotifyAudioPacketReady(0, stream_id_, filled));
   }
 }
 
 void AudioRendererImpl::WillDestroyCurrentMessageLoop() {
   DCHECK(MessageLoop::current() == io_loop_);
 
   // We treat the IO loop going away the same as stopping.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stopped_)
     return;
 
   stopped_ = true;
   DestroyTask();
 }