Report stalled event correctly for <video>

webkit/glue/webmediaplayer_impl.cc

 // Copyright (c) 2008-2009 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/glue/webmediaplayer_impl.h"
 
 #include "base/command_line.h"
 #include "googleurl/src/gurl.h"
 #include "media/base/media_format.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
@@ skipping 105 matching lines @@
 void WebMediaPlayerImpl::Proxy::PipelineEndedCallback() {
   render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &WebMediaPlayerImpl::Proxy::PipelineEndedTask));
 }
 
 void WebMediaPlayerImpl::Proxy::PipelineErrorCallback() {
   render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &WebMediaPlayerImpl::Proxy::PipelineErrorTask));
 }
 
+void WebMediaPlayerImpl::Proxy::NetworkEventCallback() {
+  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
+      &WebMediaPlayerImpl::Proxy::NetworkEventTask));
+}
+
 void WebMediaPlayerImpl::Proxy::RepaintTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   {
     AutoLock auto_lock(lock_);
     --outstanding_repaints_;
     DCHECK_GE(outstanding_repaints_, 0);
   }
   if (webmediaplayer_) {
     webmediaplayer_->Repaint();
   }
@@ skipping 20 matching lines @@
   }
 }
 
 void WebMediaPlayerImpl::Proxy::PipelineErrorTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
     webmediaplayer_->OnPipelineError();
   }
 }
 
+void WebMediaPlayerImpl::Proxy::NetworkEventTask() {
+  DCHECK(MessageLoop::current() == render_loop_);
+  if (webmediaplayer_) {
+    webmediaplayer_->OnNetworkEvent();
+  }
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // WebMediaPlayerImpl implementation
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(WebKit::WebMediaPlayerClient* client,
                                        media::FilterFactoryCollection* factory)
     : network_state_(WebKit::WebMediaPlayer::Empty),
       ready_state_(WebKit::WebMediaPlayer::HaveNothing),
       main_loop_(NULL),
       filter_factory_(factory),
       pipeline_thread_("PipelineThread"),
@@ skipping 16 matching lines @@
   main_loop_->AddDestructionObserver(this);
 
   // Creates the proxy.
   proxy_ = new Proxy(main_loop_, this);
 
   // Set our pipeline callbacks.
   pipeline_->SetPipelineEndedCallback(NewCallback(proxy_.get(),
       &WebMediaPlayerImpl::Proxy::PipelineEndedCallback));
   pipeline_->SetPipelineErrorCallback(NewCallback(proxy_.get(),
       &WebMediaPlayerImpl::Proxy::PipelineErrorCallback));
+  pipeline_->SetNetworkEventCallback(NewCallback(proxy_.get(),
+      &WebMediaPlayerImpl::Proxy::NetworkEventCallback));
 
   // Add in the default filter factories.
   filter_factory_->AddFactory(media::FFmpegDemuxer::CreateFilterFactory());
   filter_factory_->AddFactory(media::FFmpegAudioDecoder::CreateFactory());
   filter_factory_->AddFactory(media::FFmpegVideoDecoder::CreateFactory());
   filter_factory_->AddFactory(media::NullAudioRenderer::CreateFilterFactory());
   filter_factory_->AddFactory(VideoRendererImpl::CreateFactory(proxy_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
@@ skipping 286 matching lines @@
 
 void WebMediaPlayerImpl::Repaint() {
   DCHECK(MessageLoop::current() == main_loop_);
   GetClient()->repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineInitialize() {
   DCHECK(MessageLoop::current() == main_loop_);
   if (pipeline_->GetError() == media::PIPELINE_OK) {
     // Only keep one time range starting from 0.
-    WebKit::WebTimeRanges new_buffered(static_cast<size_t>(1));
+    WebKit::WebTimeRanges new_buffered(1u);
     new_buffered[0].start = 0.0f;
     new_buffered[0].end =
-        static_cast<float>(pipeline_->GetBufferedTime().InSecondsF());
+        static_cast<float>(pipeline_->GetDuration().InSecondsF());
     buffered_.swap(new_buffered);
 
     // Since we have initialized the pipeline, say we have everything.
     // TODO(hclam): change this to report the correct status.
     SetReadyState(WebKit::WebMediaPlayer::HaveMetadata);
     SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
     if (pipeline_->IsLoaded()) {
       SetNetworkState(WebKit::WebMediaPlayer::Loaded);
     } else {
       SetNetworkState(WebKit::WebMediaPlayer::Loading);
@@ skipping 54 matching lines @@
     case media::PIPELINE_ERROR_AUDIO_HARDWARE:
       // Decode error.
       SetNetworkState(WebMediaPlayer::DecodeError);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
+void WebMediaPlayerImpl::OnNetworkEvent() {
+  DCHECK(MessageLoop::current() == main_loop_);
+  if (pipeline_->GetError() == media::PIPELINE_OK) {
+    if (pipeline_->IsNetworkActive())
+      SetNetworkState(WebKit::WebMediaPlayer::Loading);
+    else
+      SetNetworkState(WebKit::WebMediaPlayer::Idle);
+  }
+}
+
 void WebMediaPlayerImpl::SetNetworkState(
     WebKit::WebMediaPlayer::NetworkState state) {
   DCHECK(MessageLoop::current() == main_loop_);
   // Always notify to ensure client has the latest value.
   network_state_ = state;
   GetClient()->networkStateChanged();
 }
 
 void WebMediaPlayerImpl::SetReadyState(
     WebKit::WebMediaPlayer::ReadyState state) {
@@ skipping 19 matching lines @@
   }
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue