Fire canplaythrough event at the proper time for audio/video

webkit/glue/webmediaplayer_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.
 
 #include "webkit/glue/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 #include "webkit/glue/media/media_stream_client.h"
 #include "webkit/glue/media/video_renderer_impl.h"
 #include "webkit/glue/media/web_video_renderer.h"
 #include "webkit/glue/webmediaplayer_delegate.h"
 #include "webkit/glue/webmediaplayer_proxy.h"
 #include "webkit/glue/webvideoframe_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebRect;
 using WebKit::WebSize;
+using media::NetworkEvent;
 using media::PipelineStatus;
 
 namespace {
 
 // Amount of extra memory used by each player instance reported to V8.
 // It is not exact number -- first, it differs on different platforms,
 // and second, it is very hard to calculate. Instead, use some arbitrary
 // value that will cause garbage collection from time to time. We don't want
 // it to happen on every allocation, but don't want 5k players to sit in memory
 // either. Looks that chosen constant achieves both goals, at least for audio
@@ skipping 58 matching lines @@
       message_loop_factory_(message_loop_factory),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       pending_seek_(false),
       client_(client),
       proxy_(NULL),
       delegate_(delegate),
       media_stream_client_(media_stream_client),
       media_log_(media_log),
-      incremented_externally_allocated_memory_(false) {
+      incremented_externally_allocated_memory_(false),
+      can_play_through_(false) {
   // Saves the current message loop.
   DCHECK(!main_loop_);
   main_loop_ = MessageLoop::current();
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 }
 
 bool WebMediaPlayerImpl::Initialize(
     WebKit::WebFrame* frame,
     bool use_simple_data_source,
@@ skipping 201 matching lines @@
     pending_seek_ = true;
     pending_seek_seconds_ = seconds;
     return;
   }
 
   media_log_->AddEvent(media_log_->CreateSeekEvent(seconds));
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
 
   // Update our paused time.
-  if (paused_) {
+  if (paused_)
     paused_time_ = seek_time;
-  }
 
   seeking_ = true;
 
   proxy_->DemuxerFlush();
 
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
       base::Bind(&WebMediaPlayerProxy::PipelineSeekCallback,
                  proxy_.get()));
@@ skipping 100 matching lines @@
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   base::TimeDelta duration = pipeline_->GetMediaDuration();
   if (duration.InMicroseconds() == media::Limits::kMaxTimeInMicroseconds)
     return std::numeric_limits<float>::infinity();
   return static_cast<float>(duration.InSecondsF());
 }
 
 float WebMediaPlayerImpl::currentTime() const {
   DCHECK_EQ(main_loop_, MessageLoop::current());
-  if (paused_) {
+  if (paused_)
     return static_cast<float>(paused_time_.InSecondsF());
-  }
   return static_cast<float>(pipeline_->GetCurrentTime().InSecondsF());
 }
 
 int WebMediaPlayerImpl::dataRate() const {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
   return 0;
 }
 
@@ skipping 220 matching lines @@
 void WebMediaPlayerImpl::OnPipelineInitialize(PipelineStatus status) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   if (status == media::PIPELINE_OK) {
     // Only keep one time range starting from 0.
     WebKit::WebTimeRanges new_buffered(static_cast<size_t>(1));
     new_buffered[0].start = 0.0f;
     new_buffered[0].end =
         static_cast<float>(pipeline_->GetMediaDuration().InSecondsF());
     buffered_.swap(new_buffered);
 
-    if (pipeline_->IsLoaded()) {
+    if (pipeline_->IsLoaded())
       SetNetworkState(WebKit::WebMediaPlayer::Loaded);
-    }
 
-    // Since we have initialized the pipeline, say we have everything otherwise
-    // we'll remain either loading/idle.
-    // TODO(hclam): change this to report the correct status.
     SetReadyState(WebKit::WebMediaPlayer::HaveMetadata);
-    SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
+    SetReadyState(WebKit::WebMediaPlayer::HaveFutureData);
   } else {
     // TODO(hclam): should use |status| to determine the state
     // properly and reports error using MediaError.
     // WebKit uses FormatError to indicate an error for bogus URL or bad file.
     // Since we are at the initialization stage we can safely treat every error
     // as format error. Should post a task to call to |webmediaplayer_|.
     SetNetworkState(WebKit::WebMediaPlayer::FormatError);
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineSeek(PipelineStatus status) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_seconds_);
     return;
   }
 
   if (status == media::PIPELINE_OK) {
     // Update our paused time.
-    if (paused_) {
+    if (paused_)
       paused_time_ = pipeline_->GetCurrentTime();
-    }
 
-    SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
+    if (!can_play_through_)

[acolwell GONE FROM CHROMIUM, 2011/11/09 00:50:22]

I just want to double check what is going on here. On the initial play we'll
likely go to HaveFutureData and at some point later a network event will trigger
the transition to HaveEnoughData. Any seek after that time will go directly to
HaveEnoughData. 

What if a second seek happens before the "can play through" network event fires?
Won't this mean that the canplaythrough will happen after the second seek? Is
that ok?

[vrk (LEFT CHROMIUM), 2011/11/11 02:51:06]

Talked in person. It appears I can get get rid of this SetReadyState call after
seek altogether! In the original code, it looks like it is always in the
HAVE_ENOUGH_DATA state whenever the code reached that point - which would also
make sense why CanPlayThrough is only fired once. I deleted the call and the
bool field.

+      SetReadyState(WebKit::WebMediaPlayer::HaveFutureData);
+    else
+      SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
+
     GetClient()->timeChanged();
   }
 }
 
 void WebMediaPlayerImpl::OnPipelineEnded(PipelineStatus status) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
-  if (status == media::PIPELINE_OK) {
+  if (status == media::PIPELINE_OK)
     GetClient()->timeChanged();
-  }
 }
 
 void WebMediaPlayerImpl::OnPipelineError(PipelineStatus error) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   switch (error) {
     case media::PIPELINE_OK:
       LOG(DFATAL) << "PIPELINE_OK isn't an error!";
       break;
 
     case media::PIPELINE_ERROR_NETWORK:
@@ skipping 23 matching lines @@
     case media::PIPELINE_ERROR_INVALID_STATE:
       // Decode error.
       SetNetworkState(WebMediaPlayer::DecodeError);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
-void WebMediaPlayerImpl::OnNetworkEvent(bool is_downloading_data) {
+void WebMediaPlayerImpl::OnNetworkEvent(NetworkEvent type) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
-  if (is_downloading_data)
-    SetNetworkState(WebKit::WebMediaPlayer::Loading);
-  else
-    SetNetworkState(WebKit::WebMediaPlayer::Idle);
+  switch(type) {
+    case media::DOWNLOAD_CONTINUED:
+      SetNetworkState(WebKit::WebMediaPlayer::Loading);
+      break;
+    case media::DOWNLOAD_PAUSED:
+      SetNetworkState(WebKit::WebMediaPlayer::Idle);
+      break;
+    case media::CAN_PLAY_THROUGH:
+      if (!can_play_through_) {

[acolwell GONE FROM CHROMIUM, 2011/11/09 00:50:22]

Do we really only want to do this once or is it ok to do this transition if
ready_state_ != WebKit::WebMediaPlayer::HaveEnoughData?

[vrk (LEFT CHROMIUM), 2011/11/11 02:51:06]

For now, I think we really only want to do this once, *but* this is the wrong
place to enforce it (it's already enforced in DownloadRateMonitor). Fixed.

+        can_play_through_ = true;

[scherkus (not reviewing), 2011/11/09 02:55:15]

so if we determine that our connection is "good enough" to satisfy the
can_play_through_ event then we assume we'll always be able to can play through
on future seeks?

[vrk (LEFT CHROMIUM), 2011/11/11 02:51:06]

Yes. It's not necessarily a good assumption, but I think it might be good enough
for an initial implementation. I'd like to leave the task of reevaluating the
"canplaythrough" condition and possibly firing it multiple times to a different
CL.

+        SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
+      }
+      break;
+   default:
+     NOTREACHED();
+  }
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GetClient()->sourceOpened();
 }
 
 void WebMediaPlayerImpl::SetNetworkState(
     WebKit::WebMediaPlayer::NetworkState state) {
@@ skipping 51 matching lines @@
   return client_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_glue