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

media/filters/video_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 "base/callback.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/callback.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
@@ skipping 21 matching lines @@
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(base::kNullThreadHandle),
       pending_reads_(0),
       pending_paint_(false),
       pending_paint_with_last_available_(false),
       playback_rate_(0) {
 }
 
 VideoRendererBase::~VideoRendererBase() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK(state_ == kUninitialized || state_ == kStopped);
 }
 
 // static
 bool VideoRendererBase::ParseMediaFormat(
     const MediaFormat& media_format,
     VideoFrame::SurfaceType* surface_type_out,
     VideoFrame::Format* surface_format_out,
     int* width_out, int* height_out) {
   std::string mime_type;
@@ skipping 18 matching lines @@
   if (!media_format.GetAsInteger(MediaFormat::kWidth, &width))
     return false;
   if (!media_format.GetAsInteger(MediaFormat::kHeight, &height))
     return false;
   if (width_out) *width_out = width;
   if (height_out) *height_out = height;
   return true;
 }
 
 void VideoRendererBase::Play(FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   scoped_ptr<FilterCallback> c(callback);
   state_ = kPlaying;
   callback->Run();
 }
 
 void VideoRendererBase::Pause(FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
   AutoCallbackRunner done_runner(callback);
   state_ = kPaused;
 }
 
 void VideoRendererBase::Flush(FilterCallback* callback) {
   DCHECK_EQ(state_, kPaused);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   flush_callback_.reset(callback);
   state_ = kFlushing;
 
   if (pending_paint_ == false)
     FlushBuffers();
 }
 
 void VideoRendererBase::Stop(FilterCallback* callback) {
   DCHECK_EQ(pending_reads_, 0);
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     state_ = kStopped;
 
     // Clean up our thread if present.
     if (thread_) {
       // Signal the thread since it's possible to get stopped with the video
       // thread waiting for a read to complete.
       frame_available_.Signal();
       {
-        AutoUnlock auto_unlock(lock_);
+        base::AutoUnlock auto_unlock(lock_);
         base::PlatformThread::Join(thread_);
       }
       thread_ = base::kNullThreadHandle;
     }
 
   }
   // Signal the subclass we're stopping.
   OnStop(callback);
 }
 
 void VideoRendererBase::SetPlaybackRate(float playback_rate) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
 void VideoRendererBase::Seek(base::TimeDelta time, FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   // There is a race condition between filters to receive SeekTask().
   // It turns out we could receive buffer from decoder before seek()
   // is called on us. so we do the following:
   // kFlushed => ( Receive first buffer or Seek() ) => kSeeking and
   // kSeeking => ( Receive enough buffers) => kPrerolled. )
   DCHECK(kPrerolled == state_ || kFlushed == state_ || kSeeking == state_);
 
   if (state_ == kPrerolled) {
     // Already get enough buffers from decoder.
     callback->Run();
     delete callback;
   } else {
     // Otherwise we are either kFlushed or kSeeking, but without enough buffers;
     // we should save the callback function and call it later.
     state_ = kSeeking;
     seek_callback_.reset(callback);
   }
 
   seek_timestamp_ = time;
   ScheduleRead_Locked();
 }
 
 void VideoRendererBase::Initialize(VideoDecoder* decoder,
                                    FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK(decoder);
   DCHECK(callback);
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
   AutoCallbackRunner done_runner(callback);
 
   decoder_->set_consume_video_frame_callback(
       NewCallback(this, &VideoRendererBase::ConsumeVideoFrame));
   // Notify the pipeline of the video dimensions.
   if (!ParseMediaFormat(decoder->media_format(),
@@ skipping 31 matching lines @@
 
 #if defined(OS_WIN)
   // Bump up our priority so our sleeping is more accurate.
   // TODO(scherkus): find out if this is necessary, but it seems to help.
   ::SetThreadPriority(thread_, THREAD_PRIORITY_ABOVE_NORMAL);
 #endif  // defined(OS_WIN)
 
 }
 
 bool VideoRendererBase::HasEnded() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   return state_ == kEnded;
 }
 
 // PlatformThread::Delegate implementation.
 void VideoRendererBase::ThreadMain() {
   base::PlatformThread::SetName("CrVideoRenderer");
   base::TimeDelta remaining_time;
 
   for (;;) {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
 
     const base::TimeDelta kIdleTimeDelta =
         base::TimeDelta::FromMilliseconds(kIdleMilliseconds);
 
     if (state_ == kStopped)
       return;
 
     if (state_ != kPlaying || playback_rate_ == 0) {
       remaining_time = kIdleTimeDelta;
     } else if (frames_queue_ready_.empty() ||
@@ skipping 76 matching lines @@
           // which is the first frame in the queue.
           timeout_frame = frames_queue_ready_.front();
           frames_queue_ready_.pop_front();
         }
       }
       if (timeout_frame.get()) {
         frames_queue_done_.push_back(timeout_frame);
         ScheduleRead_Locked();
       }
       if (new_frame_available) {
-        AutoUnlock auto_unlock(lock_);
+        base::AutoUnlock auto_unlock(lock_);
         // Notify subclass that |current_frame_| has been updated.
         OnFrameAvailable();
       }
     }
   }
 }
 
 void VideoRendererBase::GetCurrentFrame(scoped_refptr<VideoFrame>* frame_out) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK(!pending_paint_ && !pending_paint_with_last_available_);
 
   if (!current_frame_.get() || current_frame_->IsEndOfStream()) {
     if (!last_available_frame_.get() ||
         last_available_frame_->IsEndOfStream()) {
       *frame_out = NULL;
       return;
     }
   }
 
   // We should have initialized and have the current frame.
   DCHECK(state_ != kUninitialized && state_ != kStopped && state_ != kError);
 
   if (current_frame_) {
     *frame_out = current_frame_;
     last_available_frame_ = current_frame_;
     pending_paint_ = true;
   } else {
     DCHECK(last_available_frame_.get() != NULL);
     *frame_out = last_available_frame_;
     pending_paint_with_last_available_ = true;
   }
 }
 
 void VideoRendererBase::PutCurrentFrame(scoped_refptr<VideoFrame> frame) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   // Note that we do not claim |pending_paint_| when we return NULL frame, in
   // that case, |current_frame_| could be changed before PutCurrentFrame.
   if (pending_paint_) {
     DCHECK(current_frame_.get() == frame.get());
     DCHECK(pending_paint_with_last_available_ == false);
     pending_paint_ = false;
   } else if (pending_paint_with_last_available_) {
     DCHECK(last_available_frame_.get() == frame.get());
     pending_paint_with_last_available_ = false;
   } else {
     DCHECK(frame.get() == NULL);
   }
 
   // We had cleared the |pending_paint_| flag, there are chances that current
   // frame is timed-out. We will wake up our main thread to advance the current
   // frame when this is true.
   frame_available_.Signal();
   if (state_ == kFlushing)
     FlushBuffers();
 }
 
 void VideoRendererBase::ConsumeVideoFrame(scoped_refptr<VideoFrame> frame) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   // Decoder could reach seek state before our Seek() get called.
   // We will enter kSeeking
   if (kFlushed == state_)
     state_ = kSeeking;
 
   // Synchronous flush between filters should prevent this from happening.
   DCHECK_NE(state_, kStopped);
   if (frame.get() && !frame->IsEndOfStream())
     --pending_reads_;
@@ skipping 151 matching lines @@
     previous_time_ = now;
   }
 
   // Scale our sleep based on the playback rate.
   // TODO(scherkus): floating point badness and degrade gracefully.
   return base::TimeDelta::FromMicroseconds(
       static_cast<int64>(sleep.InMicroseconds() / playback_rate));
 }
 
 }  // namespace media