Fix unit test failures with estimated durations and splice frames.

media/filters/source_buffer_stream.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/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 472 matching lines @@
 
   PrepareRangesForNextAppend(buffers, &deleted_buffers);
 
   // If there's a range for |buffers|, insert |buffers| accordingly. Otherwise,
   // create a new range with |buffers|.
   if (range_for_next_append_ != ranges_.end()) {
     (*range_for_next_append_)->AppendBuffersToEnd(buffers);
     last_appended_buffer_timestamp_ = buffers.back()->GetDecodeTimestamp();
     last_appended_buffer_is_keyframe_ = buffers.back()->IsKeyframe();
   } else {
-    base::TimeDelta new_range_start_time = media_segment_start_time_;
+    base::TimeDelta new_range_start_time =

[wolenetz, 2014/04/02 00:47:07]

If we allow range starts to be < media_segment_start_time_, does that mean that
we could be mishandling some edge cases instead of properly signaling
OnNewMediaSegment with the earlier start time?

[acolwell GONE FROM CHROMIUM, 2014/04/02 17:19:33]

I believe adding a DCHECK(media_segment_start_time_ <=
buffers.front()->timestamp()) at the top of this function would mitigate this
concern. If this fires it means that the caller is doing something wrong.

[DaleCurtis, 2014/04/02 21:53:43]

DCHECK() discussion moved to: https://codereview.chromium.org/222783007/

+        std::min(media_segment_start_time_, buffers.front()->timestamp());
     const BufferQueue* buffers_for_new_range = &buffers;
     BufferQueue trimmed_buffers;
 
     // If the new range is not being created because of a new media
     // segment, then we must make sure that we start with a keyframe.
     // This can happen if the GOP in the previous append gets destroyed
     // by a Remove() call.
     if (!new_media_segment_ && !buffers.front()->IsKeyframe()) {
       BufferQueue::const_iterator itr = buffers.begin();
 
@@ skipping 1158 matching lines @@
       interbuffer_distance_cb_(interbuffer_distance_cb),
       size_in_bytes_(0) {
   DCHECK(!new_buffers.empty());
   DCHECK(new_buffers.front()->IsKeyframe());
   DCHECK(!interbuffer_distance_cb.is_null());
   AppendBuffersToEnd(new_buffers);
 }
 
 void SourceBufferRange::AppendBuffersToEnd(const BufferQueue& new_buffers) {
   DCHECK(buffers_.empty() || CanAppendBuffersToEnd(new_buffers));
+  DCHECK(media_segment_start_time_ == kNoTimestamp() ||
+         media_segment_start_time_ <=
+             new_buffers.front()->GetDecodeTimestamp());
   for (BufferQueue::const_iterator itr = new_buffers.begin();
-       itr != new_buffers.end(); ++itr) {
+       itr != new_buffers.end();
+       ++itr) {
     DCHECK((*itr)->GetDecodeTimestamp() != kNoTimestamp());
     buffers_.push_back(*itr);
     size_in_bytes_ += (*itr)->data_size();
 
     if ((*itr)->IsKeyframe()) {
       keyframe_map_.insert(
           std::make_pair((*itr)->GetDecodeTimestamp(),
                          buffers_.size() - 1 + keyframe_map_index_base_));
     }
   }
@@ skipping 488 matching lines @@
     if (buffer->end_of_stream() || buffer->timestamp() >= end)
       break;
     if (buffer->timestamp() + buffer->duration() <= start)
       continue;
     buffers->push_back(buffer);
   }
   return previous_size < buffers->size();
 }
 
 }  // namespace media