Allow transitioning to HAVE_METADATA before pipeline initialization completes.

webkit/media/webmediaplayer_impl.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 "webkit/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 113 matching lines @@
       client_(client),
       proxy_(new WebMediaPlayerProxy(main_loop_->message_loop_proxy(), this)),
       delegate_(delegate),
       media_stream_client_(media_stream_client),
       media_log_(media_log),
       accelerated_compositing_reported_(false),
       incremented_externally_allocated_memory_(false),
       audio_source_provider_(audio_source_provider),
       audio_renderer_sink_(audio_renderer_sink),
       is_local_source_(false),
-      decryptor_(proxy_.get(), client, frame) {
+      decryptor_(proxy_.get(), client, frame),
+      starting_(false) {
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   MessageLoop* pipeline_message_loop =
       message_loop_factory_->GetMessageLoop("PipelineThread");
   pipeline_ = new media::Pipeline(pipeline_message_loop, media_log_);
 
   // Let V8 know we started new thread if we did not did it yet.
   // Made separate task to avoid deletion of player currently being created.
   // Also, delaying GC until after player starts gets rid of starting lag --
@@ skipping 157 matching lines @@
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   return true;
 }
 
 void WebMediaPlayerImpl::seek(float seconds) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
-  if (seeking_) {
+  if (starting_ || seeking_) {
     pending_seek_ = true;
     pending_seek_seconds_ = seconds;
     proxy_->DemuxerCancelPendingSeek();
     return;
   }
 
   media_log_->AddEvent(media_log_->CreateSeekEvent(seconds));
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
 
@@ skipping 430 matching lines @@
   Destroy();
   main_loop_ = NULL;
 }
 
 void WebMediaPlayerImpl::Repaint() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   GetClient()->repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineInitialize(PipelineStatus status) {
+  starting_ = false;

[Ami GONE FROM CHROMIUM, 2012/08/15 18:00:08]

put below DCHECK below.

[acolwell GONE FROM CHROMIUM, 2012/08/15 23:21:15]

Done.

+
   DCHECK_EQ(main_loop_, MessageLoop::current());
   if (status != media::PIPELINE_OK) {
     // Any error that occurs before the pipeline can initialize should be
     // considered a format error.
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
     // Repaint to trigger UI update.
     Repaint();
     return;
   }
 
   if (!hasVideo())
     GetClient()->disableAcceleratedCompositing();
 
   if (is_local_source_)
     SetNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
-  SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
-  // Fire canplaythrough immediately after playback begins because of
-  // crbug.com/106480.
-  // TODO(vrk): set ready state to HaveFutureData when bug above is fixed.
-  SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+  if (!pending_seek_)
+    return;
 
-  // Repaint to trigger UI update.
-  Repaint();
+  pending_seek_ = false;
+  seek(pending_seek_seconds_);
 }
 
 void WebMediaPlayerImpl::OnPipelineSeek(PipelineStatus status) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_seconds_);
     return;
   }
@@ skipping 61 matching lines @@
 
     case media::PIPELINE_STATUS_MAX:
       NOTREACHED() << "PIPELINE_STATUS_MAX isn't a real error!";
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
+void WebMediaPlayerImpl::OnPipelineReadyState(
+    media::Pipeline::ReadyState readyState) {
+  DVLOG(1) << "OnPipelineReadyState(" << readyState << ")";
+
+  switch(readyState) {
+    case media::Pipeline::HaveMetadata:
+      SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
+      break;
+    case media::Pipeline::HaveEnoughData:
+      // Fire canplaythrough immediately after playback begins because of
+      // crbug.com/106480.
+      // TODO(vrk): set ready state to HaveFutureData when bug above is fixed.
+      SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+      break;
+  }
+
+  // Repaint to trigger UI update.
+  Repaint();
+}
+
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GetClient()->sourceOpened();
 }
 
 void WebMediaPlayerImpl::OnKeyAdded(const std::string& key_system,
                                     const std::string& session_id) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
@@ skipping 74 matching lines @@
     SetNetworkState(WebMediaPlayer::NetworkStateIdle);
   else if (is_downloading && network_state_ == WebMediaPlayer::NetworkStateIdle)
     SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           media::MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading));
 }
 
 void WebMediaPlayerImpl::StartPipeline() {
+  starting_ = true;
   pipeline_->Start(
       filter_collection_.Pass(),
       base::Bind(&WebMediaPlayerProxy::PipelineEndedCallback, proxy_.get()),
       base::Bind(&WebMediaPlayerProxy::PipelineErrorCallback, proxy_.get()),
       base::Bind(&WebMediaPlayerProxy::PipelineInitializationCallback,
+                 proxy_.get()),
+      base::Bind(&WebMediaPlayerProxy::PipelineReadyStateCallback,
                  proxy_.get()));
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   DVLOG(1) << "SetNetworkState: " << state;
   network_state_ = state;
   // Always notify to ensure client has the latest value.
   GetClient()->networkStateChanged();
 }
@@ skipping 49 matching lines @@
   return audio_source_provider_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media