Log FilterHost events in PipelineImpl 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>
@@ skipping 324 matching lines @@
 PipelineStatistics PipelineImpl::GetStatistics() const {
   base::AutoLock auto_lock(lock_);
   return statistics_;
 }
 
 void PipelineImpl::SetClockForTesting(Clock* clock) {
   clock_.reset(clock);
 }
 
 void PipelineImpl::SetCurrentReadPosition(int64 offset) {
+  media_log_->AddEvent(
+      media_log_->CreateIntegerEvent(
+          MediaLogEvent::CURRENT_READ_POSITION_SET, "read_position", offset));
   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;
@@ skipping 111 matching lines @@
   }
 }
 
 void PipelineImpl::SetError(PipelineStatus error) {
   DCHECK(IsRunning());
   DCHECK_NE(PIPELINE_OK, error);
   VLOG(1) << "Media pipeline error: " << error;
 
   message_loop_->PostTask(FROM_HERE,
      NewRunnableMethod(this, &PipelineImpl::ErrorChangedTask, error));
+
+  media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 }
 
 base::TimeDelta PipelineImpl::GetTime() const {
   DCHECK(IsRunning());
   return GetCurrentTime();
 }
 
 base::TimeDelta PipelineImpl::GetDuration() const {
   DCHECK(IsRunning());
   return GetMediaDuration();
 }
 
 void PipelineImpl::SetTime(base::TimeDelta time) {
   DCHECK(IsRunning());
+  media_log_->AddEvent(
+      media_log_->CreateTimeEvent(MediaLogEvent::TIME_SET, "time", time));
+
   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());
+  media_log_->AddEvent(
+      media_log_->CreateTimeEvent(
+          MediaLogEvent::DURATION_SET, "duration", duration));
+
   base::AutoLock auto_lock(lock_);
   duration_ = duration;
 }
 
 void PipelineImpl::SetBufferedTime(base::TimeDelta buffered_time) {
   DCHECK(IsRunning());
+  media_log_->AddEvent(
+      media_log_->CreateTimeEvent(
+          MediaLogEvent::BUFFERED_TIME_SET, "buffered_time", buffered_time));
+
   base::AutoLock auto_lock(lock_);
   buffered_time_ = buffered_time;
 }
 
 void PipelineImpl::SetTotalBytes(int64 total_bytes) {
   DCHECK(IsRunning());
+  media_log_->AddEvent(
+      media_log_->CreateIntegerEvent(
+          MediaLogEvent::TOTAL_BYTES_SET, "total_bytes", total_bytes));
+
   base::AutoLock auto_lock(lock_);
   total_bytes_ = total_bytes;
 }
 
 void PipelineImpl::SetBufferedBytes(int64 buffered_bytes) {
   DCHECK(IsRunning());
+  media_log_->AddEvent(
+      media_log_->CreateIntegerEvent(
+          MediaLogEvent::BUFFERED_BYTES_SET, "buffered_bytes", buffered_bytes));
+
   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());
+  media_log_->AddEvent(media_log_->CreateVideoSizeSetEvent(width, height));
+
   base::AutoLock auto_lock(lock_);
   video_width_ = width;
   video_height_ = height;
 }
 
 void PipelineImpl::SetStreaming(bool streaming) {
   DCHECK(IsRunning());
+  media_log_->AddEvent(
+      media_log_->CreateBooleanEvent(
+          MediaLogEvent::STREAMING_SET, "streaming", streaming));
+
   base::AutoLock auto_lock(lock_);
   streaming_ = streaming;
 }
 
 void PipelineImpl::NotifyEnded() {
   DCHECK(IsRunning());
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::NotifyEndedTask));
+  media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 }
 
 void PipelineImpl::SetLoaded(bool loaded) {
   DCHECK(IsRunning());
+  media_log_->AddEvent(
+      media_log_->CreateBooleanEvent(
+          MediaLogEvent::LOADED_SET, "loaded", loaded));
+
   base::AutoLock auto_lock(lock_);
   loaded_ = loaded;
 }
 
 void PipelineImpl::SetNetworkActivity(bool network_activity) {
   DCHECK(IsRunning());
   {
     base::AutoLock auto_lock(lock_);
     network_activity_ = network_activity;
   }
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::NotifyNetworkEventTask));
+  media_log_->AddEvent(
+      media_log_->CreateBooleanEvent(
+          MediaLogEvent::NETWORK_ACTIVITY_SET,
+          "network_activity", network_activity));
 }
 
 void PipelineImpl::DisableAudioRenderer() {
   DCHECK(IsRunning());
 
   // Disable renderer on the message loop.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::DisableAudioRendererTask));
+  media_log_->AddEvent(
+      media_log_->CreateEvent(MediaLogEvent::AUDIO_RENDERER_DISABLED));
 }
 
 // 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));
 }
 
 // Called from any thread.
@@ skipping 729 matching lines @@
     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