Inline media::Pipeline::ResetState() into initializer list.

media/base/pipeline.cc

 // Copyright (c) 2012 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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
+#include "media/base/buffers.h"
 #include "media/base/clock.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_renderer.h"
 
 using base::TimeDelta;
 
 namespace media {
 
@@ skipping 31 matching lines @@
 }
 
 struct Pipeline::PipelineInitState {
   scoped_refptr<AudioDecoder> audio_decoder;
   scoped_refptr<VideoDecoder> video_decoder;
 };
 
 Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
     : message_loop_(message_loop->message_loop_proxy()),
       media_log_(media_log),
+      running_(false),
+      seek_pending_(false),
+      stop_pending_(false),
+      tearing_down_(false),
+      error_caused_teardown_(false),
+      playback_rate_change_pending_(false),
+      did_loading_progress_(false),
+      total_bytes_(0),
+      natural_size_(0, 0),
+      volume_(1.0f),
+      playback_rate_(0.0f),
+      pending_playback_rate_(0.0f),
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
+      status_(PIPELINE_OK),
+      has_audio_(false),
+      has_video_(false),
       state_(kCreated),
+      seek_timestamp_(kNoTimestamp()),
+      audio_disabled_(false),
       creation_time_(base::Time::Now()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
-  ResetState();
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
 
 Pipeline::~Pipeline() {
   base::AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(!stop_pending_);
   DCHECK(!seek_pending_);
 
@@ skipping 148 matching lines @@
 
 PipelineStatistics Pipeline::GetStatistics() const {
   base::AutoLock auto_lock(lock_);
   return statistics_;
 }
 
 void Pipeline::SetClockForTesting(Clock* clock) {
   clock_.reset(clock);
 }
 
-void Pipeline::ResetState() {
-  base::AutoLock auto_lock(lock_);
-  const TimeDelta kZero;
-  running_          = false;
-  stop_pending_     = false;
-  seek_pending_     = false;
-  tearing_down_     = false;
-  error_caused_teardown_ = false;
-  playback_rate_change_pending_ = false;
-  buffered_byte_ranges_.clear();
-  did_loading_progress_ = false;
-  total_bytes_      = 0;
-  natural_size_.SetSize(0, 0);
-  volume_           = 1.0f;
-  playback_rate_    = 0.0f;
-  pending_playback_rate_ = 0.0f;
-  status_           = PIPELINE_OK;
-  has_audio_        = false;
-  has_video_        = false;
-  waiting_for_clock_update_ = false;
-  audio_disabled_   = false;
-  clock_->Reset();
-}
-
 void Pipeline::SetState(State next_state) {
   if (state_ != kStarted && next_state == kStarted &&
       !creation_time_.is_null()) {
     UMA_HISTOGRAM_TIMES(
         "Media.TimeToPipelineStarted", base::Time::Now() - creation_time_);
     creation_time_ = base::Time();
   }
   state_ = next_state;
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
 }
@@ skipping 36 matching lines @@
   // Prevent double-reporting of errors to clients.
   if (status != PIPELINE_OK)
     error_cb_.Reset();
 }
 
 void Pipeline::FinishInitialization() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   // Execute the seek callback, if present.  Note that this might be the
   // initial callback passed into Start().
   ReportStatus(seek_cb_, status_);
+  seek_timestamp_ = kNoTimestamp();
   seek_cb_.Reset();
 }
 
 // static
 bool Pipeline::TransientState(State state) {
   return state == kPausing ||
          state == kFlushing ||
          state == kSeeking ||
          state == kStarting ||
          state == kStopping;
@@ skipping 572 matching lines @@
     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.
   SetState(FindNextState(state_));
   if (state_ == kSeeking) {
     base::AutoLock auto_lock(lock_);
+    DCHECK(seek_timestamp_ != kNoTimestamp());
     clock_->SetTime(seek_timestamp_, seek_timestamp_);
   }
 
   // Carry out the action for the current state.
   if (TransientState(state_)) {
     if (state_ == kPausing) {
       DoPause(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else if (state_ == kFlushing) {
       DoFlush(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else if (state_ == kSeeking) {
@@ skipping 82 matching lines @@
 
   audio_renderer_ = NULL;
   video_renderer_ = NULL;
   demuxer_ = NULL;
 
   if (error_caused_teardown_ && !IsPipelineOk() && !error_cb_.is_null())
     error_cb_.Run(status_);
 
   if (stop_pending_) {
     stop_pending_ = false;
-    ResetState();
+    {
+      base::AutoLock l(lock_);
+      running_ = false;
+    }
+
     // Notify the client that stopping has finished.
     base::ResetAndReturn(&stop_cb_).Run();
   }
 
   tearing_down_ = false;
   error_caused_teardown_ = false;
 }
 
 void Pipeline::InitializeDemuxer() {
   DCHECK(message_loop_->BelongsToCurrentThread());
@@ skipping 246 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media