preparation for recycling buffer, patch 2

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/condition_variable.h"
@@ skipping 39 matching lines @@
       return "DemuxerThread";
     case FILTER_AUDIO_DECODER:
       return "AudioDecoderThread";
     case FILTER_VIDEO_DECODER:
       return "VideoDecoderThread";
     default:
       return "FilterThread";
   }
 }
 
-// Helper function used with NewRunnableMethod to implement a (very) crude
-// blocking counter.
-//
-// TODO(scherkus): remove this as soon as Stop() is made asynchronous.
-void DecrementCounter(Lock* lock, ConditionVariable* cond_var, int* count) {
-  AutoLock auto_lock(*lock);
-  --(*count);
-  CHECK(*count >= 0);
-  if (*count == 0) {
-    cond_var->Signal();
-  }
-}
-
 }  // namespace
 
 PipelineImpl::PipelineImpl(MessageLoop* message_loop)
     : message_loop_(message_loop),
       clock_(&base::Time::Now),
       waiting_for_clock_update_(false),
       state_(kCreated),
       remaining_transitions_(0),
       current_bytes_(0) {
   ResetState();
@@ skipping 59 matching lines @@
   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_);
   switch (state_) {
     case kPausing:
+    case kFlushing:
     case kSeeking:
     case kStarting:
     case kStarted:
     case kEnded:
       return true;
     default:
       return false;
   }
 }
 
@@ skipping 213 matching lines @@
   if (seek_callback_.get()) {
     seek_callback_->Run();
     seek_callback_.reset();
   }
   filter_factory_ = NULL;
 }
 
 // static
 bool PipelineImpl::TransientState(State state) {
   return state == kPausing ||
+         state == kFlushing ||
          state == kSeeking ||
          state == kStarting ||
          state == kStopping;
 }
 
 // static
 PipelineImpl::State PipelineImpl::FindNextState(State current) {
   // TODO(scherkus): refactor InitializeTask() to make use of this function.
   if (current == kPausing)
+    return kFlushing;
+  if (current == kFlushing)
     return kSeeking;
   if (current == kSeeking)
     return kStarting;
   if (current == kStarting)
     return kStarted;
   if (current == kStopping)
     return kStopped;
   return current;
 }
 
@@ skipping 431 matching lines @@
     if (TransientState(state_)) {
       remaining_transitions_ = filters_.size();
     }
   }
 
   // Carry out the action for the current state.
   if (TransientState(state_)) {
     MediaFilter* filter = filters_[filters_.size() - remaining_transitions_];
     if (state_ == kPausing) {
       filter->Pause(NewCallback(this, &PipelineImpl::OnFilterStateTransition));
+    } else if (state_ == kFlushing) {
+      filter->Flush(NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kSeeking) {
       filter->Seek(seek_timestamp_,
           NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kStarting) {
       filter->Play(NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kStopping) {
       filter->Stop(NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else {
       NOTREACHED();
     }
@@ skipping 183 matching lines @@
     filters_.front()->Stop(NewCallback(
         this, &PipelineImpl::OnFilterStateTransition));
   } else {
     state_ = kStopped;
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
   }
 }
 
 }  // namespace media