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

media/base/pipeline_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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/stl_util-inl.h"
@@ skipping 17 matching lines @@
 PipelineImpl::PipelineImpl(MessageLoop* message_loop)
     : message_loop_(message_loop),
       clock_(new ClockImpl(&base::Time::Now)),
       waiting_for_clock_update_(false),
       state_(kCreated),
       current_bytes_(0) {
   ResetState();
 }
 
 PipelineImpl::~PipelineImpl() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(!stop_pending_);
   DCHECK(!seek_pending_);
 }
 
 void PipelineImpl::Init(PipelineCallback* ended_callback,
                         PipelineCallback* error_callback,
                         PipelineCallback* network_callback) {
   DCHECK(!IsRunning())
       << "Init() should be called before the pipeline has started";
   ended_callback_.reset(ended_callback);
   error_callback_.reset(error_callback);
   network_callback_.reset(network_callback);
 }
 
 // Creates the PipelineInternal and calls it's start method.
 bool PipelineImpl::Start(FilterCollection* collection,
                          const std::string& url,
                          PipelineCallback* start_callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   scoped_ptr<PipelineCallback> callback(start_callback);
   scoped_ptr<FilterCollection> filter_collection(collection);
 
   if (running_) {
     VLOG(1) << "Media pipeline is already running";
     return false;
   }
 
   if (collection->IsEmpty()) {
     return false;
   }
 
   // Kick off initialization!
   running_ = true;
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &PipelineImpl::StartTask,
                         filter_collection.release(),
                         url,
                         callback.release()));
   return true;
 }
 
 void PipelineImpl::Stop(PipelineCallback* stop_callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   scoped_ptr<PipelineCallback> callback(stop_callback);
   if (!running_) {
     VLOG(1) << "Media pipeline has already stopped";
     return;
   }
 
   // Stop the pipeline, which will set |running_| to false on behalf.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::StopTask, callback.release()));
 }
 
 void PipelineImpl::Seek(base::TimeDelta time,
                         PipelineCallback* seek_callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   scoped_ptr<PipelineCallback> callback(seek_callback);
   if (!running_) {
     VLOG(1) << "Media pipeline must be running";
     return;
   }
 
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::SeekTask, time,
                         callback.release()));
 }
 
 bool PipelineImpl::IsRunning() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return running_;
 }
 
 bool PipelineImpl::IsInitialized() const {
   // TODO(scherkus): perhaps replace this with a bool that is set/get under the
   // lock, because this is breaching the contract that |state_| is only accessed
   // on |message_loop_|.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   switch (state_) {
     case kPausing:
     case kFlushing:
     case kSeeking:
     case kStarting:
     case kStarted:
     case kEnded:
       return true;
     default:
       return false;
   }
 }
 
 bool PipelineImpl::IsNetworkActive() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return network_activity_;
 }
 
 bool PipelineImpl::IsRendered(const std::string& major_mime_type) const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   bool is_rendered = (rendered_mime_types_.find(major_mime_type) !=
                       rendered_mime_types_.end());
   return is_rendered;
 }
 
 float PipelineImpl::GetPlaybackRate() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return playback_rate_;
 }
 
 void PipelineImpl::SetPlaybackRate(float playback_rate) {
   if (playback_rate < 0.0f) {
     return;
   }
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
   if (running_) {
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::PlaybackRateChangedTask,
                           playback_rate));
   }
 }
 
 float PipelineImpl::GetVolume() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return volume_;
 }
 
 void PipelineImpl::SetVolume(float volume) {
   if (volume < 0.0f || volume > 1.0f) {
     return;
   }
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_) {
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::VolumeChangedTask,
                           volume));
   }
 }
 
 base::TimeDelta PipelineImpl::GetCurrentTime() const {
   // TODO(scherkus): perhaps replace checking state_ == kEnded with a bool that
   // is set/get under the lock, because this is breaching the contract that
   // |state_| is only accessed on |message_loop_|.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return GetCurrentTime_Locked();
 }
 
 base::TimeDelta PipelineImpl::GetCurrentTime_Locked() const {
   base::TimeDelta elapsed = clock_->Elapsed();
   if (state_ == kEnded || elapsed > duration_) {
     return duration_;
   }
   return elapsed;
 }
 
 base::TimeDelta PipelineImpl::GetBufferedTime() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   // If media is fully loaded, then return duration.
   if (loaded_ || total_bytes_ == buffered_bytes_) {
     max_buffered_time_ = duration_;
     return duration_;
   }
 
   base::TimeDelta current_time = GetCurrentTime_Locked();
 
   // If buffered time was set, we report that value directly.
@@ skipping 19 matching lines @@
   // Make sure buffered_time is at least the current time
   buffered_time = std::max(buffered_time, current_time);
 
   // Only print the max buffered time for smooth buffering.
   max_buffered_time_ = std::max(buffered_time, max_buffered_time_);
 
   return max_buffered_time_;
 }
 
 base::TimeDelta PipelineImpl::GetMediaDuration() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return duration_;
 }
 
 int64 PipelineImpl::GetBufferedBytes() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return buffered_bytes_;
 }
 
 int64 PipelineImpl::GetTotalBytes() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return total_bytes_;
 }
 
 void PipelineImpl::GetVideoSize(size_t* width_out, size_t* height_out) const {
   CHECK(width_out);
   CHECK(height_out);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   *width_out = video_width_;
   *height_out = video_height_;
 }
 
 bool PipelineImpl::IsStreaming() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return streaming_;
 }
 
 bool PipelineImpl::IsLoaded() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return loaded_;
 }
 
 PipelineError PipelineImpl::GetError() const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return error_;
 }
 
 void PipelineImpl::SetCurrentReadPosition(int64 offset) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   // The current read position should never be ahead of the buffered byte
   // position but threading issues between BufferedDataSource::DoneRead_Locked()
   // and BufferedDataSource::NetworkEventCallback() can cause them to be
   // temporarily out of sync. The easiest fix for this is to cap both
   // buffered_bytes_ and current_bytes_ to always be legal values in
   // SetCurrentReadPosition() and in SetBufferedBytes().
   if (offset > buffered_bytes_)
     buffered_bytes_ = offset;
   current_bytes_ = offset;
 }
 
 int64 PipelineImpl::GetCurrentReadPosition() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return current_bytes_;
 }
 
 void PipelineImpl::ResetState() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   const base::TimeDelta kZero;
   running_          = false;
   stop_pending_     = false;
   seek_pending_     = false;
   tearing_down_     = false;
   duration_         = kZero;
   buffered_time_    = kZero;
   buffered_bytes_   = 0;
   streaming_        = false;
   loaded_           = false;
@@ skipping 105 matching lines @@
   return GetCurrentTime();
 }
 
 base::TimeDelta PipelineImpl::GetDuration() const {
   DCHECK(IsRunning());
   return GetMediaDuration();
 }
 
 void PipelineImpl::SetTime(base::TimeDelta time) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   // If we were waiting for a valid timestamp and such timestamp arrives, we
   // need to clear the flag for waiting and start the clock.
   if (waiting_for_clock_update_) {
     if (time < clock_->Elapsed())
       return;
     waiting_for_clock_update_ = false;
     clock_->SetTime(time);
     clock_->Play();
     return;
   }
   clock_->SetTime(time);
 }
 
 void PipelineImpl::SetDuration(base::TimeDelta duration) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   duration_ = duration;
 }
 
 void PipelineImpl::SetBufferedTime(base::TimeDelta buffered_time) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   buffered_time_ = buffered_time;
 }
 
 void PipelineImpl::SetTotalBytes(int64 total_bytes) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   total_bytes_ = total_bytes;
 }
 
 void PipelineImpl::SetBufferedBytes(int64 buffered_bytes) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   // See comments in SetCurrentReadPosition() about capping.
   if (buffered_bytes < current_bytes_)
     current_bytes_ = buffered_bytes;
   buffered_bytes_ = buffered_bytes;
 }
 
 void PipelineImpl::SetVideoSize(size_t width, size_t height) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   video_width_ = width;
   video_height_ = height;
 }
 
 void PipelineImpl::SetStreaming(bool streaming) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   streaming_ = streaming;
 }
 
 void PipelineImpl::NotifyEnded() {
   DCHECK(IsRunning());
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::NotifyEndedTask));
 }
 
 void PipelineImpl::SetLoaded(bool loaded) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   loaded_ = loaded;
 }
 
 void PipelineImpl::SetNetworkActivity(bool network_activity) {
   DCHECK(IsRunning());
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     network_activity_ = network_activity;
   }
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::NotifyNetworkEventTask));
 }
 
 void PipelineImpl::DisableAudioRenderer() {
   DCHECK(IsRunning());
 
   // Disable renderer on the message loop.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::DisableAudioRendererTask));
 }
 
 void PipelineImpl::InsertRenderedMimeType(const std::string& major_mime_type) {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   rendered_mime_types_.insert(major_mime_type);
 }
 
 bool PipelineImpl::HasRenderedMimeTypes() const {
   DCHECK(IsRunning());
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return !rendered_mime_types_.empty();
 }
 
 // Called from any thread.
 void PipelineImpl::OnFilterInitialize() {
   // Continue the initialize task by proceeding to the next stage.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::InitializeTask));
 }
 
@@ skipping 145 matching lines @@
   PipelineError error = GetError();
 
   if (state_ == kStopped || (IsPipelineStopPending() && error == PIPELINE_OK)) {
     // If we are already stopped or stopping normally, return immediately.
     delete stop_callback;
     return;
   } else if (state_ == kError ||
              (IsPipelineStopPending() && error != PIPELINE_OK)) {
     // If we are stopping due to SetError(), stop normally instead of
     // going to error state.
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     error_ = PIPELINE_OK;
   }
 
   stop_callback_.reset(stop_callback);
 
   stop_pending_ = true;
   if (!IsPipelineSeeking()) {
     // We will tear down pipeline immediately when there is no seek operation
     // pending. This should include the case where we are partially initialized.
     // Ideally this case should use SetError() rather than Stop() to tear down.
     DCHECK(!IsPipelineTearingDown());
     TearDownPipeline();
   }
 }
 
 void PipelineImpl::ErrorChangedTask(PipelineError error) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
   // Suppress executing additional error logic. Note that if we are currently
   // performing a normal stop, then we return immediately and continue the
   // normal stop.
   if (IsPipelineStopped() || IsPipelineTearingDown()) {
     return;
   }
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   error_ = error;
 
   TearDownPipeline();
 }
 
 void PipelineImpl::PlaybackRateChangedTask(float playback_rate) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     clock_->SetPlaybackRate(playback_rate);
   }
 
   // Notify |pipeline_filter_| if it has been initialized. If initialization
   // hasn't completed yet, the playback rate will be set when initialization
   // completes.
   if (pipeline_filter_) {
     pipeline_filter_->SetPlaybackRate(playback_rate);
   }
 }
@@ skipping 30 matching lines @@
   //   kPausing (for each filter)
   //   kSeeking (for each filter)
   //   kStarting (for each filter)
   //   kStarted
   set_state(kPausing);
   seek_timestamp_ = time;
   seek_callback_.reset(seek_callback);
 
   // Kick off seeking!
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     // If we are waiting for a clock update, the clock hasn't been played yet.
     if (!waiting_for_clock_update_)
       clock_->Pause();
   }
   pipeline_filter_->Pause(
       NewCallback(this, &PipelineImpl::OnFilterStateTransition));
 }
 
 void PipelineImpl::NotifyEndedTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
@@ skipping 35 matching lines @@
   if (network_callback_.get()) {
     network_callback_->Run();
   }
 }
 
 void PipelineImpl::DisableAudioRendererTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // |rendered_mime_types_| is read through public methods so we need to lock
   // this variable.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   rendered_mime_types_.erase(mime_type::kMajorTypeAudio);
 
   audio_disabled_ = true;
 
   // Notify all filters of disabled audio renderer. If the filter isn't
   // initialized yet, OnAudioRendererDisabled() will be called when
   // initialization is complete.
   if (pipeline_filter_) {
     pipeline_filter_->OnAudioRendererDisabled();
   }
@@ skipping 10 matching lines @@
   if (!TransientState(state_)) {
     NOTREACHED() << "Invalid current state: " << state_;
     SetError(PIPELINE_ERROR_ABORT);
     return;
   }
 
   // Decrement the number of remaining transitions, making sure to transition
   // to the next state if needed.
   set_state(FindNextState(state_));
   if (state_ == kSeeking) {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     clock_->SetTime(seek_timestamp_);
   }
 
   // Carry out the action for the current state.
   if (TransientState(state_)) {
     if (state_ == kPausing) {
       pipeline_filter_->Pause(
           NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kFlushing) {
       pipeline_filter_->Flush(
@@ skipping 10 matching lines @@
     } else {
       NOTREACHED() << "Unexpected state: " << state_;
     }
   } else if (state_ == kStarted) {
     FinishInitialization();
 
     // Finally, reset our seeking timestamp back to zero.
     seek_timestamp_ = base::TimeDelta();
     seek_pending_ = false;
 
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     // We use audio stream to update the clock. So if there is such a stream,
     // we pause the clock until we receive a valid timestamp.
     waiting_for_clock_update_ =
         rendered_mime_types_.find(mime_type::kMajorTypeAudio) !=
         rendered_mime_types_.end();
     if (!waiting_for_clock_update_)
       clock_->Play();
 
     if (IsPipelineStopPending()) {
       // We had a pending stop request need to be honored right now.
@@ skipping 235 matching lines @@
     pipeline_filter_->Pause(NewCallback(
         this, &PipelineImpl::OnFilterStateTransition));
   } else {
     set_state(kStopped);
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
   }
 }
 
 }  // namespace media