WebMediaPlayerAndroid - handling unseekable durations

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 368 matching lines @@
     pending_seek_ = true;
     pending_seek_time_ = new_seek_time;
 
     if (media_source_delegate_)
       media_source_delegate_->CancelPendingSeek(pending_seek_time_);
 
     // Later, OnSeekComplete will trigger the pending seek.
     return;
   }
 
+  if (new_seek_time >=

[acolwell GONE FROM CHROMIUM, 2014/01/13 16:32:07]

This should not be needed if maxTimeSeekable() never returns a value greater
than std::numeric_limits<int32>max().

[amogh.bihani, 2014/01/14 08:03:09]

Done.

+          base::TimeDelta::FromMilliseconds(std::numeric_limits<int32>max())) {
+    return;
+  }
+
   seeking_ = true;
   seek_time_ = new_seek_time;
 
   if (media_source_delegate_)
     media_source_delegate_->StartWaitingForSeek(seek_time_);
 
   // Kick off the asynchronous seek!
   manager_->Seek(player_id_, seek_time_);
 }
 
@@ skipping 96 matching lines @@
     return media_source_delegate_->Buffered();
   return buffered_;
 }
 
 double WebMediaPlayerAndroid::maxTimeSeekable() const {
   // If we haven't even gotten to ReadyStateHaveMetadata yet then just
   // return 0 so that the seekable range is empty.
   if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
     return 0.0;
 
-  // TODO(hclam): If this stream is not seekable this should return 0.

[amogh.bihani, 2014/01/13 11:43:14]

This is handled in this patch automatically

   return duration();

[acolwell GONE FROM CHROMIUM, 2014/01/13 16:32:07]

This does not see right to me. I believe this should be
std::min(std::numeric_limits<int32>max(), duration()) instead so that the
seekable range is never too large. This allow Blink to prevent invalid seek
values from ever being passed to seek().

[amogh.bihani, 2014/01/14 08:03:09]

Done.

 }
 
 bool WebMediaPlayerAndroid::didLoadingProgress() const {
   bool ret = did_loading_progress_;
   did_loading_progress_ = false;
   return ret;
 }
 
 void WebMediaPlayerAndroid::paint(blink::WebCanvas* canvas,
                                   const blink::WebRect& rect,
@@ skipping 95 matching lines @@
 
 void WebMediaPlayerAndroid::OnMediaMetadataChanged(
     const base::TimeDelta& duration, int width, int height, bool success) {
   bool need_to_signal_duration_changed = false;
 
   if (url_.SchemeIs("file"))
     UpdateNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   // Update duration, if necessary, prior to ready state updates that may
   // cause duration() query.
-  // TODO(wolenetz): Correctly handle durations that MediaSourcePlayer
-  // considers unseekable, including kInfiniteDuration().

[amogh.bihani, 2014/01/13 11:43:14]

kInfiniteDuration is 2^63, so this is automatically handled

-  // See http://crbug.com/248396
+
+  // MediaSourcePlayer assumes duration more than 2^31 as unseekable
+  // because java player uses 32-bit integer for time at millisecond resolution
+  if (duration >=

[acolwell GONE FROM CHROMIUM, 2014/01/13 16:32:07]

This does not seem right. The clip duration and the seekable range are 2
different concepts. I don't think it is correct to prevent duration updates just
because the seekable range is smaller than the duration. The duration update
should be allowed to proceed and as long as maxTimeSeekable() is returning the
right information, Blink should prevent seeks from outside the seekable range.
If it isn't then we probably need to make a change to the Blink code instead.

[amogh.bihani, 2014/01/14 08:03:09]

Done.

+          base::TimeDelta::FromMilliseconds(std::numeric_limits<int32>max())) {
+    return;
+  }
+
   if (!ignore_metadata_duration_change_ && duration_ != duration) {
     duration_ = duration;
 
     // Client readyState transition from HAVE_NOTHING to HAVE_METADATA
     // already triggers a durationchanged event. If this is a different
     // transition, remember to signal durationchanged.
     // Do not ever signal durationchanged on metadata change in MSE case
     // because OnDurationChanged() handles this.
     if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing &&
         player_type_ != MEDIA_PLAYER_TYPE_MEDIA_SOURCE) {
@@ skipping 186 matching lines @@
 
 void WebMediaPlayerAndroid::OnRequestFullscreen() {
   client_->requestFullscreen();
 }
 
 void WebMediaPlayerAndroid::OnDurationChanged(const base::TimeDelta& duration) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   // Only MSE |player_type_| registers this callback.
   DCHECK_EQ(player_type_, MEDIA_PLAYER_TYPE_MEDIA_SOURCE);
 
+  // MediaSourcePlayer assumes duration more than 2^31 as unseekable
+  // because java player uses 32-bit integer for time at millisecond resolution
+  if (duration >=
+          base::TimeDelta::FromMilliseconds(std::numeric_limits<int32>max())) {
+    return;
+  }
+
   // Cache the new duration value and trust it over any subsequent duration
   // values received in OnMediaMetadataChanged().
-  // TODO(wolenetz): Correctly handle durations that MediaSourcePlayer
-  // considers unseekable, including kInfiniteDuration().
-  // See http://crbug.com/248396
   duration_ = duration;
   ignore_metadata_duration_change_ = true;
 
   // Notify MediaPlayerClient that duration has changed, if > HAVE_NOTHING.
   if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing)
     client_->durationChanged();
 }
 
 void WebMediaPlayerAndroid::UpdateNetworkState(
     WebMediaPlayer::NetworkState state) {
@@ skipping 616 matching lines @@
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   manager_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content