Ensure media's buffered ranges always have a range that includes currentTime.

media/filters/chunk_demuxer.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 "media/filters/chunk_demuxer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 63 matching lines @@
 
 static const SupportedTypeInfo kSupportedTypeInfo[] = {
   { "video/webm", &BuildWebMParser, kVideoWebMCodecs },
   { "audio/webm", &BuildWebMParser, kAudioWebMCodecs },
 #if defined(USE_PROPRIETARY_CODECS)
   { "video/mp4", &BuildMP4Parser, kVideoMP4Codecs },
   { "audio/mp4", &BuildMP4Parser, kAudioMP4Codecs },
 #endif
 };
 
-
-// The fake total size we use for converting times to bytes
-// for AddBufferedByteRange() calls.
-// TODO(acolwell): Remove this once Pipeline accepts buffered times
-// instead of only buffered bytes.
-enum { kFakeTotalBytes = 1000000 };
-
 // Checks to see if the specified |type| and |codecs| list are supported.
 // Returns true if |type| and all codecs listed in |codecs| are supported.
 //         |factory_function| contains a function that can build a StreamParser
 //                            for this type.
 //         |has_audio| is true if an audio codec was specified.
 //         |has_video| is true if a video codec was specified.
 // Returns false otherwise. The values of |factory_function|, |has_audio|,
 //         and |has_video| are undefined.
 static bool IsSupported(const std::string& type,
                         std::vector<std::string>& codecs,
@@ skipping 645 matching lines @@
       if (audio_ && !video_) {
         ranges = audio_->GetBufferedTime();
       } else if (!audio_ && video_) {
         ranges = video_->GetBufferedTime();
       } else {
         ranges = ComputeIntersection();
       }
     }
   }
 
-  DCHECK(!ranges.size() || duration_ > TimeDelta());
-  for (size_t i = 0; i < ranges.size(); ++i) {
-    // Notify the host of 'network activity' because we got data.
-    int64 start =
-        kFakeTotalBytes * ranges.start(i).InSecondsF() / duration_.InSecondsF();
-    int64 end =
-        kFakeTotalBytes * ranges.end(i).InSecondsF() / duration_.InSecondsF();
-    host_->AddBufferedByteRange(start, end);
-  }
+  for (size_t i = 0; i < ranges.size(); ++i)
+    host_->AddBufferedTimeRange(ranges.start(i), ranges.end(i));
 
   if (!cb.is_null())
     cb.Run(PIPELINE_OK);
 
   return true;
 }
 
 void ChunkDemuxer::Abort(const std::string& id) {
   DVLOG(1) << "Abort(" << id << ")";
   DCHECK(!id.empty());
@@ skipping 147 matching lines @@
   }
 
   if (duration > duration_)
     duration_ = duration;
 
   // Wait until all streams have initialized.
   if ((!source_id_audio_.empty() && !audio_) ||
       (!source_id_video_.empty() && !video_))
     return;
 
-  if (duration_ > TimeDelta() && duration_ != kInfiniteDuration())
-    host_->SetTotalBytes(kFakeTotalBytes);
   host_->SetDuration(duration_);
 
   ChangeState_Locked(INITIALIZED);
   PipelineStatusCB cb;
   std::swap(cb, init_cb_);
   cb.Run(PIPELINE_OK);
 }
 
 bool ChunkDemuxer::OnNewConfigs(bool has_audio, bool has_video,
                                 const AudioDecoderConfig& audio_config,
@@ skipping 68 matching lines @@
   // TODO(vrk): There should be a special case for the first appends where all
   // streams (for both demuxed and muxed case) begin at the earliest stream
   // timestamp. (crbug.com/132815)
   if (audio_ && source_id == source_id_audio_)
     audio_->OnNewMediaSegment(start_timestamp);
   if (video_ && source_id == source_id_video_)
     video_->OnNewMediaSegment(start_timestamp);
 }
 
 }  // namespace media