MSE: Use CHECKs to obtain more detail on hard-to-repro crashes

media/filters/source_buffer_range.cc

 // Copyright 2014 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_range.h"
 
 #include <algorithm>
 
 #include "media/base/timestamp_constants.h"
 
@@ skipping 80 matching lines @@
     }
   }
 }
 
 void SourceBufferRange::Seek(DecodeTimestamp timestamp) {
   DCHECK(CanSeekTo(timestamp));
   DCHECK(!keyframe_map_.empty());
 
   KeyframeMap::iterator result = GetFirstKeyframeAtOrBefore(timestamp);
   next_buffer_index_ = result->second - keyframe_map_index_base_;
-  DCHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()));
+  CHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()))
+      << next_buffer_index_ << ", size = " << buffers_.size();
 }
 
 void SourceBufferRange::SeekAheadTo(DecodeTimestamp timestamp) {
   SeekAhead(timestamp, false);
 }
 
 void SourceBufferRange::SeekAheadPast(DecodeTimestamp timestamp) {
   SeekAhead(timestamp, true);
 }
 
 void SourceBufferRange::SeekAhead(DecodeTimestamp timestamp,
                                   bool skip_given_timestamp) {
   DCHECK(!keyframe_map_.empty());
 
   KeyframeMap::iterator result =
       GetFirstKeyframeAt(timestamp, skip_given_timestamp);
 
   // If there isn't a keyframe after |timestamp|, then seek to end and return
   // kNoTimestamp to signal such.
   if (result == keyframe_map_.end()) {
     next_buffer_index_ = -1;
     return;
   }
   next_buffer_index_ = result->second - keyframe_map_index_base_;
   DCHECK_LT(next_buffer_index_, static_cast<int>(buffers_.size()));
 }
 
 void SourceBufferRange::SeekToStart() {
-  DCHECK(!buffers_.empty());
+  CHECK(!buffers_.empty());
   next_buffer_index_ = 0;
 }
 
 SourceBufferRange* SourceBufferRange::SplitRange(DecodeTimestamp timestamp) {
   CHECK(!buffers_.empty());
 
   // Find the first keyframe at or after |timestamp|.
   KeyframeMap::iterator new_beginning_keyframe =
       GetFirstKeyframeAt(timestamp, false);
 
@@ skipping 25 matching lines @@
   // Create a new range with |removed_buffers|.
   SourceBufferRange* split_range =
       new SourceBufferRange(
           gap_policy_, removed_buffers, new_range_start_timestamp,
           interbuffer_distance_cb_);
 
   // If the next buffer position is now in |split_range|, update the state of
   // this range and |split_range| accordingly.
   if (next_buffer_index_ >= static_cast<int>(buffers_.size())) {
     split_range->next_buffer_index_ = next_buffer_index_ - keyframe_index;
+    CHECK_GE(split_range->next_buffer_index_, 0)
+        << split_range->next_buffer_index_;
     ResetNextBufferPosition();
   }
 
   return split_range;
 }
 
 SourceBufferRange::BufferQueue::iterator SourceBufferRange::GetBufferItrAt(
     DecodeTimestamp timestamp,
     bool skip_given_timestamp) {
   return skip_given_timestamp
@@ skipping 70 matching lines @@
     deleted_buffers->push_back(buffers_.front());
     buffers_.pop_front();
     ++buffers_deleted;
   }
 
   // Update |keyframe_map_index_base_| to account for the deleted buffers.
   keyframe_map_index_base_ += buffers_deleted;
 
   if (next_buffer_index_ > -1) {
     next_buffer_index_ -= buffers_deleted;
-    DCHECK_GE(next_buffer_index_, 0);
+    CHECK_GE(next_buffer_index_, 0) << next_buffer_index_ << ", deleted "
+                                    << buffers_deleted;
   }
 
   // Invalidate media segment start time if we've deleted the first buffer of
   // the range.
   if (buffers_deleted > 0)
     media_segment_start_time_ = kNoDecodeTimestamp();
 
   return total_bytes_deleted;
 }
 
@@ skipping 159 matching lines @@
   next_buffer_index_++;
   return true;
 }
 
 bool SourceBufferRange::HasNextBuffer() const {
   return next_buffer_index_ >= 0 &&
       next_buffer_index_ < static_cast<int>(buffers_.size());
 }
 
 int SourceBufferRange::GetNextConfigId() const {
-  DCHECK(HasNextBuffer());
+  CHECK(HasNextBuffer()) << next_buffer_index_;
   // If the next buffer is an audio splice frame, the next effective config id
   // comes from the first fade out preroll buffer.
   return buffers_[next_buffer_index_]->GetSpliceBufferConfigId(0);
 }
 
 DecodeTimestamp SourceBufferRange::GetNextTimestamp() const {
-  DCHECK(!buffers_.empty());
-  DCHECK(HasNextBufferPosition());
+  CHECK(!buffers_.empty()) << next_buffer_index_;
+  CHECK(HasNextBufferPosition()) << next_buffer_index_
+                                 << ", size=" << buffers_.size();
 
   if (next_buffer_index_ >= static_cast<int>(buffers_.size())) {
     return kNoDecodeTimestamp();
   }
 
   return buffers_[next_buffer_index_]->GetDecodeTimestamp();
 }
 
 bool SourceBufferRange::HasNextBufferPosition() const {
   return next_buffer_index_ >= 0;
@@ skipping 156 matching lines @@
     }
 
     if (buffer->timestamp() + buffer->duration() <= start.ToPresentationTime())
       continue;
     buffers->push_back(buffer);
   }
   return previous_size < buffers->size();
 }
 
 }  // namespace media