Revert "If duration of media source is unknown then return NaN."

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/android/build_info.h"
 #include "base/bind.h"
@@ skipping 123 matching lines @@
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
       stream_id_(0),
       is_playing_(false),
       needs_establish_peer_(true),
       has_size_info_(false),
       compositor_loop_(
           RenderThreadImpl::current()->compositor_message_loop_proxy()),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
-      has_valid_metadata_(false),
       video_frame_provider_client_(NULL),
       pending_playback_(false),
       player_type_(MEDIA_PLAYER_TYPE_URL),
       is_remote_(false),
       media_log_(media_log),
       web_cdm_(NULL),
       allow_stored_credentials_(false),
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       weak_factory_(this) {
@@ skipping 286 matching lines @@
   return !is_playing_;
 }
 
 bool WebMediaPlayerAndroid::seeking() const {
   return seeking_;
 }
 
 double WebMediaPlayerAndroid::duration() const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // HTML5 spec requires duration to be NaN if readyState is HAVE_NOTHING
-  if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing ||
-      !has_valid_metadata_)
+  if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return std::numeric_limits<double>::quiet_NaN();
 
   if (duration_ == media::kInfiniteDuration())
     return std::numeric_limits<double>::infinity();
 
   return duration_.InSecondsF();
 }
 
 double WebMediaPlayerAndroid::timelineOffset() const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 35 matching lines @@
 
 WebTimeRanges WebMediaPlayerAndroid::buffered() const {
   if (media_source_delegate_)
     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 ||
-      !has_valid_metadata_)
+  if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
     return 0.0;
 
   return duration();
 }
 
 bool WebMediaPlayerAndroid::didLoadingProgress() {
   bool ret = did_loading_progress_;
   did_loading_progress_ = false;
   return ret;
 }
@@ skipping 220 matching lines @@
     // 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) {
       need_to_signal_duration_changed = true;
     }
   }
 
-  // UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata) will trigger a
-  // call to duration(), which checks |has_valid_metadata_|. so
-  // |has_valid_metadata_| has to be updated before calling UpdateReadyState().
-  has_valid_metadata_ = success;
   if (ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   }
 
   // TODO(wolenetz): Should we just abort early and set network state to an
   // error if success == false? See http://crbug.com/248399
   if (success)
     OnVideoSizeChanged(width, height);
 
@@ skipping 13 matching lines @@
   // to 0. It will perform a seek to 0. As the requests to the renderer
   // process are sequential, the OnSeekComplete() will only occur
   // once OnPlaybackComplete() is done. As the playback can only be executed
   // upon completion of OnSeekComplete(), the request needs to be saved.
   UpdatePlayingState(false);
   if (seeking_ && seek_time_ == base::TimeDelta())
     pending_playback_ = true;
 }
 
 void WebMediaPlayerAndroid::OnBufferingUpdate(int percentage) {
-  buffered_[0].end = has_valid_metadata_ ? duration() * percentage / 100 : 0;
+  buffered_[0].end = duration() * percentage / 100;
   did_loading_progress_ = true;
 }
 
 void WebMediaPlayerAndroid::OnSeekRequest(const base::TimeDelta& time_to_seek) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   client_->requestSeek(time_to_seek.InSecondsF());
 }
 
 void WebMediaPlayerAndroid::OnSeekComplete(
     const base::TimeDelta& current_time) {
@@ skipping 1036 matching lines @@
 
 bool WebMediaPlayerAndroid::IsHLSStream() const {
   std::string mime;
   GURL url = redirected_url_.is_empty() ? url_ : redirected_url_;
   if (!net::GetMimeTypeFromFile(base::FilePath(url.path()), &mime))
     return false;
   return !mime.compare("application/x-mpegurl");
 }
 
 }  // namespace content