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

media/filters/audio_renderer_base.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/filters/audio_renderer_base.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 10 matching lines @@
       pending_reads_(0) {
 }
 
 AudioRendererBase::~AudioRendererBase() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
 void AudioRendererBase::Play(FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPaused, state_);
   scoped_ptr<FilterCallback> c(callback);
   state_ = kPlaying;
   callback->Run();
 }
 
 void AudioRendererBase::Pause(FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPlaying, state_);
   pause_callback_.reset(callback);
   state_ = kPaused;
 
   // We'll only pause when we've finished all pending reads.
   if (pending_reads_ == 0) {
     pause_callback_->Run();
     pause_callback_.reset();
   } else {
     state_ = kPaused;
   }
 }
 
 void AudioRendererBase::Stop(FilterCallback* callback) {
   OnStop();
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     state_ = kStopped;
     algorithm_.reset(NULL);
   }
   if (callback) {
     callback->Run();
     delete callback;
   }
 }
 
 void AudioRendererBase::Seek(base::TimeDelta time, FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPaused, state_);
   DCHECK_EQ(0u, pending_reads_) << "Pending reads should have completed";
   state_ = kSeeking;
   seek_callback_.reset(callback);
   seek_timestamp_ = time;
 
   // Throw away everything and schedule our reads.
   last_fill_buffer_time_ = base::TimeDelta();
   recieved_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
@@ skipping 44 matching lines @@
     callback->Run();
     return;
   }
 
   // Finally, execute the start callback.
   state_ = kPaused;
   callback->Run();
 }
 
 bool AudioRendererBase::HasEnded() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (rendered_end_of_stream_) {
     DCHECK(algorithm_->IsQueueEmpty())
         << "Audio queue should be empty if we have rendered end of stream";
   }
   return recieved_end_of_stream_ && rendered_end_of_stream_;
 }
 
 void AudioRendererBase::ConsumeAudioSamples(scoped_refptr<Buffer> buffer_in) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying);
   DCHECK_GT(pending_reads_, 0u);
   --pending_reads_;
 
   // TODO(scherkus): this happens due to a race, primarily because Stop() is a
   // synchronous call when it should be asynchronous and accept a callback.
   // Refer to http://crbug.com/16059
   if (state_ == kStopped) {
     return;
   }
@@ skipping 32 matching lines @@
 
 uint32 AudioRendererBase::FillBuffer(uint8* dest,
                                      uint32 dest_len,
                                      const base::TimeDelta& playback_delay,
                                      bool buffers_empty) {
   // The timestamp of the last buffer written during the last call to
   // FillBuffer().
   base::TimeDelta last_fill_buffer_time;
   size_t dest_written = 0;
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
 
     // Mute audio by returning 0 when not playing.
     if (state_ != kPlaying) {
       // TODO(scherkus): To keep the audio hardware busy we write at most 8k of
       // zeros.  This gets around the tricky situation of pausing and resuming
       // the audio IPC layer in Chrome.  Ideally, we should return zero and then
       // the subclass can restart the conversation.
       const uint32 kZeroLength = 8192;
       dest_written = std::min(kZeroLength, dest_len);
       memset(dest, 0, dest_written);
@@ skipping 64 matching lines @@
 
 void AudioRendererBase::SetPlaybackRate(float playback_rate) {
   algorithm_->set_playback_rate(playback_rate);
 }
 
 float AudioRendererBase::GetPlaybackRate() {
   return algorithm_->playback_rate();
 }
 
 }  // namespace media