Implementing preload=metadata for video

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 201 matching lines @@
 
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_) {
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::VolumeChangedTask,
                           volume));
   }
 }
 
+Preload PipelineImpl::GetPreload() const {
+  base::AutoLock auto_lock(lock_);
+  return preload_;
+}
+
+void PipelineImpl::SetPreload(Preload preload) {
+  base::AutoLock auto_lock(lock_);
+  preload_ = preload;
+  if (running_) {
+    message_loop_->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &PipelineImpl::PreloadChangedTask,
+                          preload));
+  }
+}
+
 base::TimeDelta PipelineImpl::GetCurrentTime() const {
   // TODO(scherkus): perhaps replace checking state_ == kEnded with a bool that
   // is set/get under the lock, because this is breaching the contract that
   // |state_| is only accessed on |message_loop_|.
   base::AutoLock auto_lock(lock_);
   return GetCurrentTime_Locked();
 }
 
 base::TimeDelta PipelineImpl::GetCurrentTime_Locked() const {
   base::TimeDelta elapsed = clock_->Elapsed();
@@ skipping 446 matching lines @@
     pipeline_init_state_.reset();
 
     if (audio_disabled_) {
       // Audio was disabled at some point during initialization. Notify
       // the pipeline filter now that it has been initialized.
       pipeline_filter_->OnAudioRendererDisabled();
     }
 
     // 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);
     seek_timestamp_ = base::TimeDelta();
     pipeline_filter_->Seek(seek_timestamp_,
         NewCallback(this, &PipelineImpl::OnFilterStateTransition));
   }
@@ skipping 80 matching lines @@
 }
 
 void PipelineImpl::VolumeChangedTask(float volume) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (audio_renderer_) {
     audio_renderer_->SetVolume(volume);
   }
 }
 
+void PipelineImpl::PreloadChangedTask(Preload preload) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  if (demuxer_)
+    demuxer_->SetPreload(preload);
+}
+
 void PipelineImpl::SeekTask(base::TimeDelta time,
                             PipelineStatusCallback* seek_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!IsPipelineStopPending());
 
   // Suppress seeking if we're not fully started.
   if (state_ != kStarted && state_ != kEnded) {
     // TODO(scherkus): should we run the callback?  I'm tempted to say the API
     // will only execute the first Seek() request.
     VLOG(1) << "Media pipeline has not started, ignoring seek to "
@@ skipping 189 matching lines @@
       break;
     // default: intentionally left out to force new states to cause compiler
     // errors.
   };
 }
 
 void PipelineImpl::FinishDestroyingFiltersTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineStopped());
 
-  // Clear renderer references.
+  // Clear filter references.
   audio_renderer_ = NULL;
   video_renderer_ = NULL;
+  demuxer_ = NULL;
 
   pipeline_filter_ = NULL;
 
   if (error_caused_teardown_ && !IsPipelineOk() && error_callback_.get())
     error_callback_->Run(status_);
 
   if (stop_pending_) {
     stop_pending_ = false;
     ResetState();
     scoped_ptr<PipelineStatusCallback> stop_callback(stop_callback_.release());
@@ skipping 40 matching lines @@
   }
 
   if (!demuxer) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return;
   }
 
   if (!PrepareFilter(demuxer))
     return;
 
   pipeline_init_state_->demuxer_ = demuxer;

[acolwell GONE FROM CHROMIUM, 2011/03/25 04:35:28]

Remove demuxer_ from pipeline_init_state since PipelineImpl now has requires a
reference. This just makes things consistent with audio_renderer_ &
video_renderer_

[vrk (LEFT CHROMIUM), 2011/03/25 21:33:32]

Done.

+  demuxer_ = demuxer;
   OnFilterInitialize();
 }
 
 bool PipelineImpl::InitializeAudioDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       demuxer->GetStream(DemuxerStream::AUDIO);
@@ skipping 162 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