Change ChunkDemuxerStream/SourceBufferStream memory limit to size_t type

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 <sstream>
 
@@ skipping 588 matching lines @@
 
 void SourceBufferStream::SetConfigIds(const BufferQueue& buffers) {
   for (BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     (*itr)->SetConfigId(append_config_index_);
   }
 }
 
 void SourceBufferStream::GarbageCollectIfNeeded() {
   // Compute size of |ranges_|.
-  int ranges_size = 0;
+  size_t ranges_size = 0;
   for (RangeList::iterator itr = ranges_.begin(); itr != ranges_.end(); ++itr)
     ranges_size += (*itr)->size_in_bytes();
 
   // Return if we're under or at the memory limit.
   if (ranges_size <= memory_limit_)
     return;
 
-  int bytes_to_free = ranges_size - memory_limit_;
+  size_t bytes_to_free = ranges_size - memory_limit_;
 
   DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName() << ": Before GC"
            << " ranges_size=" << ranges_size
            << " ranges_=" << RangesToString(ranges_)
            << " memory_limit_=" << memory_limit_;
 
   // Begin deleting after the last appended buffer.
-  int bytes_freed = FreeBuffersAfterLastAppended(bytes_to_free);
+  size_t bytes_freed = FreeBuffersAfterLastAppended(bytes_to_free);
 
   // Begin deleting from the front.
-  if (bytes_to_free - bytes_freed > 0)
+  if (bytes_freed < bytes_to_free)
     bytes_freed += FreeBuffers(bytes_to_free - bytes_freed, false);
 
   // Begin deleting from the back.
-  if (bytes_to_free - bytes_freed > 0)
+  if (bytes_freed < bytes_to_free)
     bytes_freed += FreeBuffers(bytes_to_free - bytes_freed, true);
 
   DVLOG(2) << __FUNCTION__ << " " << GetStreamTypeName() << ": After GC"
            << " bytes_freed=" << bytes_freed
            << " ranges_=" << RangesToString(ranges_);
 }
 
-int SourceBufferStream::FreeBuffersAfterLastAppended(int total_bytes_to_free) {
+size_t SourceBufferStream::FreeBuffersAfterLastAppended(
+    size_t total_bytes_to_free) {
   DecodeTimestamp next_buffer_timestamp = GetNextBufferTimestamp();
   if (last_appended_buffer_timestamp_ == kNoDecodeTimestamp() ||
       next_buffer_timestamp == kNoDecodeTimestamp() ||
       last_appended_buffer_timestamp_ >= next_buffer_timestamp) {
     return 0;
   }
 
   DecodeTimestamp remove_range_start = last_appended_buffer_timestamp_;
   if (last_appended_buffer_is_keyframe_)
     remove_range_start += GetMaxInterbufferDistance();
 
   DecodeTimestamp remove_range_start_keyframe = FindKeyframeAfterTimestamp(
       remove_range_start);
   if (remove_range_start_keyframe != kNoDecodeTimestamp())
     remove_range_start = remove_range_start_keyframe;
   if (remove_range_start >= next_buffer_timestamp)
     return 0;
 
   DecodeTimestamp remove_range_end;
-  int bytes_freed = GetRemovalRange(
-      remove_range_start, next_buffer_timestamp, total_bytes_to_free,
-      &remove_range_end);
+  size_t bytes_freed = GetRemovalRange(remove_range_start,
+                                       next_buffer_timestamp,
+                                       total_bytes_to_free,
+                                       &remove_range_end);
   if (bytes_freed > 0) {
     Remove(remove_range_start.ToPresentationTime(),
            remove_range_end.ToPresentationTime(),
            next_buffer_timestamp.ToPresentationTime());
   }
 
   return bytes_freed;
 }
 
-int SourceBufferStream::GetRemovalRange(
+size_t SourceBufferStream::GetRemovalRange(
     DecodeTimestamp start_timestamp, DecodeTimestamp end_timestamp,
-    int total_bytes_to_free, DecodeTimestamp* removal_end_timestamp) {
+    size_t total_bytes_to_free, DecodeTimestamp* removal_end_timestamp) {
   DCHECK(start_timestamp >= DecodeTimestamp()) << start_timestamp.InSecondsF();
   DCHECK(start_timestamp < end_timestamp)
       << "start " << start_timestamp.InSecondsF()
       << ", end " << end_timestamp.InSecondsF();
 
-  int bytes_to_free = total_bytes_to_free;
-  int bytes_freed = 0;
+  size_t bytes_freed = 0;
 
   for (RangeList::iterator itr = ranges_.begin();
-       itr != ranges_.end() && bytes_to_free > 0; ++itr) {
+       itr != ranges_.end() && bytes_freed < total_bytes_to_free; ++itr) {
     SourceBufferRange* range = *itr;
     if (range->GetStartTimestamp() >= end_timestamp)
       break;
     if (range->GetEndTimestamp() < start_timestamp)
       continue;
 
-    int bytes_removed = range->GetRemovalGOP(
+    size_t bytes_to_free = total_bytes_to_free - bytes_freed;
+    size_t bytes_removed = range->GetRemovalGOP(
         start_timestamp, end_timestamp, bytes_to_free, removal_end_timestamp);
-    bytes_to_free -= bytes_removed;
     bytes_freed += bytes_removed;
   }
   return bytes_freed;
 }
 
-int SourceBufferStream::FreeBuffers(int total_bytes_to_free,
-                                    bool reverse_direction) {
+size_t SourceBufferStream::FreeBuffers(size_t total_bytes_to_free,
+                                       bool reverse_direction) {
   TRACE_EVENT2("media", "SourceBufferStream::FreeBuffers",
                "total bytes to free", total_bytes_to_free,
                "reverse direction", reverse_direction);
 
-  DCHECK_GT(total_bytes_to_free, 0);
-  int bytes_to_free = total_bytes_to_free;
-  int bytes_freed = 0;
+  DCHECK_GT(total_bytes_to_free, 0u);
+  size_t bytes_freed = 0;
 
   // This range will save the last GOP appended to |range_for_next_append_|
   // if the buffers surrounding it get deleted during garbage collection.
   SourceBufferRange* new_range_for_append = NULL;
 
-  while (!ranges_.empty() && bytes_to_free > 0) {
+  while (!ranges_.empty() && bytes_freed < total_bytes_to_free) {
     SourceBufferRange* current_range = NULL;
     BufferQueue buffers;
-    int bytes_deleted = 0;
+    size_t bytes_deleted = 0;
 
     if (reverse_direction) {
       current_range = ranges_.back();
       if (current_range->LastGOPContainsNextBufferPosition()) {
         DCHECK_EQ(current_range, selected_range_);
         break;
       }
       bytes_deleted = current_range->DeleteGOPFromBack(&buffers);
     } else {
       current_range = ranges_.front();
@@ skipping 10 matching lines @@
       DCHECK(last_appended_buffer_timestamp_ != kNoDecodeTimestamp());
       DCHECK(!new_range_for_append);
       // Create a new range containing these buffers.
       new_range_for_append = new SourceBufferRange(
           TypeToGapPolicy(GetType()),
           buffers, kNoDecodeTimestamp(),
           base::Bind(&SourceBufferStream::GetMaxInterbufferDistance,
                      base::Unretained(this)));
       range_for_next_append_ = ranges_.end();
     } else {
-      bytes_to_free -= bytes_deleted;
       bytes_freed += bytes_deleted;
     }
 
     if (current_range->size_in_bytes() == 0) {
       DCHECK_NE(current_range, selected_range_);
       DCHECK(range_for_next_append_ == ranges_.end() ||
              *range_for_next_append_ != current_range);
       delete current_range;
       reverse_direction ? ranges_.pop_back() : ranges_.pop_front();
     }
@@ skipping 842 matching lines @@
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media