Log PipelineImpl events to MediaLog.

media/base/pipeline_impl.cc

 // Copyright (c) 2011 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 "media/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/clock.h"
 #include "media/base/filter_collection.h"
+#include "media/base/media_log.h"
 
 namespace media {
 
 const char kRawMediaScheme[] = "x-raw-media";
 
 PipelineStatusNotification::PipelineStatusNotification()
     : cv_(&lock_), status_(PIPELINE_OK), notified_(false) {
   callback_.reset(NewCallback(this, &PipelineStatusNotification::Notify));
 }
 
@@ skipping 25 matching lines @@
   return status_;
 }
 
 class PipelineImpl::PipelineInitState {
  public:
   scoped_refptr<AudioDecoder> audio_decoder_;
   scoped_refptr<VideoDecoder> video_decoder_;
   scoped_refptr<CompositeFilter> composite_;
 };
 
-PipelineImpl::PipelineImpl(MessageLoop* message_loop)
+PipelineImpl::PipelineImpl(MessageLoop* message_loop, MediaLog* media_log)
     : message_loop_(message_loop),
+      media_log_(media_log),
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
       state_(kCreated),
       current_bytes_(0) {
+  media_log_->SetPipelineState(kCreated);
   ResetState();
+  media_log_->AddEventOfType(MediaLogEvent::PIPELINE_CREATED);
 }
 
 PipelineImpl::~PipelineImpl() {
   base::AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(!stop_pending_);
   DCHECK(!seek_pending_);
+
+  media_log_->AddEventOfType(MediaLogEvent::PIPELINE_DESTROYED);
 }
 
 void PipelineImpl::Init(PipelineStatusCallback* ended_callback,
                         PipelineStatusCallback* error_callback,
                         PipelineStatusCallback* 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);
@@ skipping 285 matching lines @@
   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_->SetTime(kZero);
 }
 
-void PipelineImpl::set_state(State next_state) {
+void PipelineImpl::SetState(State next_state) {
   state_ = next_state;
+  media_log_->SetPipelineState(next_state);
 }
 
 bool PipelineImpl::IsPipelineOk() {
   base::AutoLock auto_lock(lock_);
   return status_ == PIPELINE_OK;
 }
 
 bool PipelineImpl::IsPipelineStopped() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   return state_ == kStopped || state_ == kError;
@@ skipping 218 matching lines @@
   seek_callback_.reset(start_callback);
 
   // Kick off initialization.
   pipeline_init_state_.reset(new PipelineInitState());
   pipeline_init_state_->composite_ = new CompositeFilter(message_loop_);
   pipeline_init_state_->composite_->set_host(this);
 
   bool raw_media = (base::strncasecmp(url.c_str(), kRawMediaScheme,
                                       strlen(kRawMediaScheme)) == 0);
   if (raw_media) {
-    set_state(kInitVideoDecoder);
+    SetState(kInitVideoDecoder);
     InitializeVideoDecoder(NULL);
   } else {
-    set_state(kInitDemuxer);
+    SetState(kInitDemuxer);
     InitializeDemuxer();
   }
 }
 
 // Main initialization method called on the pipeline thread.  This code attempts
 // to use the specified filter factory to build a pipeline.
 // Initialization step performed in this method depends on current state of this
 // object, indicated by |state_|.  After each step of initialization, this
 // object transits to the next stage.  It starts by creating a Demuxer, and then
 // connects the Demuxer's audio stream to an AudioDecoder which is then
@@ skipping 17 matching lines @@
 
   DCHECK(state_ == kInitDemuxer ||
          state_ == kInitAudioDecoder ||
          state_ == kInitAudioRenderer ||
          state_ == kInitVideoDecoder ||
          state_ == kInitVideoRenderer);
 
 
   // Demuxer created, create audio decoder.
   if (state_ == kInitDemuxer) {
-    set_state(kInitAudioDecoder);
+    SetState(kInitAudioDecoder);
     // If this method returns false, then there's no audio stream.
     if (InitializeAudioDecoder(demuxer_))
       return;
   }
 
   // Assuming audio decoder was created, create audio renderer.
   if (state_ == kInitAudioDecoder) {
-    set_state(kInitAudioRenderer);
+    SetState(kInitAudioRenderer);
+
     // Returns false if there's no audio stream.
     if (InitializeAudioRenderer(pipeline_init_state_->audio_decoder_)) {
       base::AutoLock auto_lock(lock_);
       has_audio_ = true;
       return;
     }
   }
 
   // Assuming audio renderer was created, create video decoder.
   if (state_ == kInitAudioRenderer) {
     // Then perform the stage of initialization, i.e. initialize video decoder.
-    set_state(kInitVideoDecoder);
+    SetState(kInitVideoDecoder);
     if (InitializeVideoDecoder(demuxer_))
       return;
   }
 
   // Assuming video decoder was created, create video renderer.
   if (state_ == kInitVideoDecoder) {
-    set_state(kInitVideoRenderer);
+    SetState(kInitVideoRenderer);
     if (InitializeVideoRenderer(pipeline_init_state_->video_decoder_)) {
       base::AutoLock auto_lock(lock_);
       has_video_ = true;
       return;
     }
   }
 
   if (state_ == kInitVideoRenderer) {
     if (!IsPipelineOk() || !(HasAudio() || HasVideo())) {
       SetError(PIPELINE_ERROR_COULD_NOT_RENDER);
@@ skipping 15 matching lines @@
     }
 
     // Initialization was successful, we are now considered paused, so it's safe
     // to set the initial playback rate and volume.
     PreloadChangedTask(GetPreload());
     PlaybackRateChangedTask(GetPlaybackRate());
     VolumeChangedTask(GetVolume());
 
     // Fire the seek request to get the filters to preroll.
     seek_pending_ = true;
-    set_state(kSeeking);
+    SetState(kSeeking);
     if (demuxer_)
       seek_timestamp_ = demuxer_->GetStartTime();
     else
       seek_timestamp_ = base::TimeDelta();
 
     pipeline_filter_->Seek(
         seek_timestamp_,
         base::Bind(&PipelineImpl::OnFilterStateTransitionWithStatus, this));
   }
 }
@@ skipping 118 matching lines @@
   DCHECK(!seek_pending_);
   seek_pending_ = true;
 
   // We'll need to pause every filter before seeking.  The state transition
   // is as follows:
   //   kStarted/kEnded
   //   kPausing (for each filter)
   //   kSeeking (for each filter)
   //   kStarting (for each filter)
   //   kStarted
-  set_state(kPausing);
+  SetState(kPausing);
   seek_timestamp_ = time;
   seek_callback_.reset(seek_callback);
 
   // Kick off seeking!
   {
     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();
   }
@@ skipping 23 matching lines @@
       waiting_for_clock_update_ = false;
       clock_->Play();
     }
   }
 
   if (video_renderer_ && !video_renderer_->HasEnded()) {
     return;
   }
 
   // Transition to ended, executing the callback if present.
-  set_state(kEnded);
+  SetState(kEnded);
   if (ended_callback_.get()) {
     ended_callback_->Run(status_);
   }
 }
 
 void PipelineImpl::NotifyNetworkEventTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   if (network_callback_.get()) {
     network_callback_->Run(status_);
   }
@@ skipping 29 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_));
+  SetState(FindNextState(state_));
   if (state_ == kSeeking) {
     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));
@@ skipping 39 matching lines @@
     }
   } else {
     NOTREACHED() << "Unexpected state: " << state_;
   }
 }
 
 void PipelineImpl::TeardownStateTransitionTask() {
   DCHECK(IsPipelineTearingDown());
   switch (state_) {
     case kStopping:
-      set_state(error_caused_teardown_ ? kError : kStopped);
+      SetState(error_caused_teardown_ ? kError : kStopped);
       FinishDestroyingFiltersTask();
       break;
     case kPausing:
-      set_state(kFlushing);
+      SetState(kFlushing);
       pipeline_filter_->Flush(
           NewCallback(this, &PipelineImpl::OnTeardownStateTransition));
       break;
     case kFlushing:
-      set_state(kStopping);
+      SetState(kStopping);
       pipeline_filter_->Stop(
           NewCallback(this, &PipelineImpl::OnTeardownStateTransition));
       break;
 
     case kCreated:
     case kError:
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
     case kInitVideoDecoder:
@@ skipping 206 matching lines @@
   DCHECK(!tearing_down_ ||  // Teardown on Stop().
          (tearing_down_ && error_caused_teardown_) ||  // Teardown on error.
          (tearing_down_ && stop_pending_));  // Stop during teardown by error.
 
   // Mark that we already start tearing down operation.
   tearing_down_ = true;
 
   switch (state_) {
     case kCreated:
     case kError:
-      set_state(kStopped);
+      SetState(kStopped);
       // Need to put this in the message loop to make sure that it comes
       // after any pending callback tasks that are already queued.
       message_loop_->PostTask(FROM_HERE,
           NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
       break;
 
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
     case kInitVideoDecoder:
     case kInitVideoRenderer:
       // Make it look like initialization was successful.
       pipeline_filter_ = pipeline_init_state_->composite_;
       pipeline_init_state_.reset();
       filter_collection_.reset();
 
-      set_state(kStopping);
+      SetState(kStopping);
       pipeline_filter_->Stop(
           NewCallback(this, &PipelineImpl::OnTeardownStateTransition));
 
       FinishInitialization();
       break;
 
     case kPausing:
     case kSeeking:
     case kFlushing:
     case kStarting:
-      set_state(kStopping);
+      SetState(kStopping);
       pipeline_filter_->Stop(
           NewCallback(this, &PipelineImpl::OnTeardownStateTransition));
 
       if (seek_pending_) {
         seek_pending_ = false;
         FinishInitialization();
       }
 
       break;
 
     case kStarted:
     case kEnded:
-      set_state(kPausing);
+      SetState(kPausing);
       pipeline_filter_->Pause(
           NewCallback(this, &PipelineImpl::OnTeardownStateTransition));
       break;
 
     case kStopping:
     case kStopped:
       NOTREACHED() << "Unexpected state for teardown: " << state_;
       break;
     // default: intentionally left out to force new states to cause compiler
     // errors.
   };
 }
 
 }  // namespace media