Support setting an explicit duration on MediaSource objects

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 <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 163 matching lines @@
   void StartWaitingForSeek();
   void Seek(TimeDelta time);
   void CancelPendingSeek();
   bool IsSeekPending() const;
 
   // Add buffers to this stream.  Buffers are stored in SourceBufferStreams,
   // which handle ordering and overlap resolution.
   // Returns true if buffers were successfully added.
   bool Append(const StreamParser::BufferQueue& buffers);
 
+  // Signal to the stream that duration has changed to |duration|.
+  void OnSetDuration(base::TimeDelta duration);
+
   // Returns the range of buffered data in this stream, capped at |duration|.
   Ranges<TimeDelta> GetBufferedRanges(base::TimeDelta duration) const;
 
   // Signal to the stream that buffers handed in through subsequent calls to
   // Append() belong to a media segment that starts at |start_timestamp|.
   void OnNewMediaSegment(TimeDelta start_timestamp);
 
   // Called when mid-stream config updates occur.
   // Returns true if the new config is accepted.
   // Returns false if the new config should trigger an error.
@@ skipping 134 matching lines @@
     }
     CreateReadDoneClosures_Locked(&closures);
   }
 
   for (ClosureQueue::iterator it = closures.begin(); it != closures.end(); ++it)
     it->Run();
 
   return true;
 }
 
+void ChunkDemuxerStream::OnSetDuration(base::TimeDelta duration) {
+  base::AutoLock auto_lock(lock_);
+  stream_->OnSetDuration(duration);
+}
+
 Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges(
     base::TimeDelta duration) const {
   base::AutoLock auto_lock(lock_);
   Ranges<TimeDelta> range = stream_->GetBufferedTime();
 
   if (range.size() == 0u)
     return range;
 
   // Clamp the end of the stream's buffered ranges to fit within the duration.
   // This can be done by intersecting the stream's range with the valid time
@@ skipping 469 matching lines @@
 }
 
 void ChunkDemuxer::Abort(const std::string& id) {
   DVLOG(1) << "Abort(" << id << ")";
   DCHECK(!id.empty());
   CHECK(IsValidId(id));
 
   stream_parser_map_[id]->Flush();
 }
 
+void ChunkDemuxer::SetDuration(base::TimeDelta duration) {
+  DVLOG(1) << "SetDuration(" << duration.InSecondsF() << ")";
+
+  UpdateDuration(duration);

[acolwell GONE FROM CHROMIUM, 2012/08/24 18:19:10]

I think you need a 
if(duration != duration_)
  return;

otherwise I believe 'mediaSource.duration = mediaSource.duration;' in JavaScript
will DCHECK.

[vrk (LEFT CHROMIUM), 2012/08/28 00:03:22]

Did == instead :)

+
+  if (audio_)
+    audio_->OnSetDuration(duration);
+
+  if (video_)
+    video_->OnSetDuration(duration);
+}
+
 bool ChunkDemuxer::SetTimestampOffset(const std::string& id, TimeDelta offset) {
   DVLOG(1) << "SetTimestampOffset(" << id << ", " << offset.InSecondsF() << ")";
   CHECK(IsValidId(id));
 
   if (!source_info_map_[id].can_update_offset)
     return false;
 
   source_info_map_[id].timestamp_offset = offset;
   return true;
 }
@@ skipping 319 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media