Change ChunkDemuxerStream/SourceBufferStream memory limit to size_t type

media/filters/source_buffer_stream.h

 // 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.
 
 // SourceBufferStream is a data structure that stores media Buffers in ranges.
 // Buffers can be appended out of presentation order. Buffers are retrieved by
 // seeking to the desired start point and calling GetNextBuffer(). Buffers are
 // returned in sequential presentation order.
 
 #ifndef MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_
 #define MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_
 
 #include <deque>
 #include <list>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/media_export.h"
 #include "media/base/media_log.h"
 #include "media/base/ranges.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 
 namespace media {
@@ skipping 106 matching lines @@
 
   // Notifies this object that the video config has changed and buffers in
   // future Append() calls should be associated with this new config.
   bool UpdateVideoConfig(const VideoDecoderConfig& config);
 
   // Returns the largest distance between two adjacent buffers in this stream,
   // or an estimate if no two adjacent buffers have been appended to the stream
   // yet.
   base::TimeDelta GetMaxInterbufferDistance() const;
 
-  void set_memory_limit(int memory_limit) {
+  void set_memory_limit(size_t memory_limit) {
     memory_limit_ = memory_limit;
   }
 
  private:
   friend class SourceBufferStreamTest;
 
   // Frees up space if the SourceBufferStream is taking up too much memory.
   void GarbageCollectIfNeeded();
 
   // Attempts to delete approximately |total_bytes_to_free| amount of data
   // |ranges_|, starting at the front of |ranges_| and moving linearly forward
   // through the buffers. Deletes starting from the back if |reverse_direction|
   // is true. Returns the number of bytes freed.
-  int FreeBuffers(int total_bytes_to_free, bool reverse_direction);
+  size_t FreeBuffers(size_t total_bytes_to_free, bool reverse_direction);
 
   // Attempts to delete approximately |total_bytes_to_free| amount of data from
   // |ranges_|, starting after the last appended buffer before the current
   // playback position.
-  int FreeBuffersAfterLastAppended(int total_bytes_to_free);
+  size_t FreeBuffersAfterLastAppended(size_t total_bytes_to_free);
 
   // Gets the removal range to secure |byte_to_free| from
   // [|start_timestamp|, |end_timestamp|).
   // Returns the size of buffers to secure if future
   // Remove(|start_timestamp|, |removal_end_timestamp|, duration) is called.
   // Will not update |removal_end_timestamp| if the returned size is 0.
-  int GetRemovalRange(DecodeTimestamp start_timestamp,
-      DecodeTimestamp end_timestamp, int byte_to_free,
-      DecodeTimestamp* removal_end_timestamp);
+  size_t GetRemovalRange(DecodeTimestamp start_timestamp,
+                         DecodeTimestamp end_timestamp, size_t byte_to_free,
+                         DecodeTimestamp* removal_end_timestamp);
 
   // Prepares |range_for_next_append_| so |new_buffers| can be appended.
   // This involves removing buffers between the end of the previous append
   // and any buffers covered by the time range in |new_buffers|.
   // |deleted_buffers| is an output parameter containing candidates for
   // |track_buffer_| if this method ends up removing the current playback
   // position from the range.
   void PrepareRangesForNextAppend(const BufferQueue& new_buffers,
                                   BufferQueue* deleted_buffers);
 
@@ skipping 205 matching lines @@
 
   // The decode timestamp on the last buffer returned by the most recent
   // GetNextBuffer() call. Set to kNoDecodeTimestamp() if GetNextBuffer() hasn't
   // been called yet or a seek has happened since the last GetNextBuffer() call.
   DecodeTimestamp last_output_buffer_timestamp_;
 
   // Stores the largest distance between two adjacent buffers in this stream.
   base::TimeDelta max_interbuffer_distance_;
 
   // The maximum amount of data in bytes the stream will keep in memory.
-  int memory_limit_;
+  size_t memory_limit_;
 
   // Indicates that a kConfigChanged status has been reported by GetNextBuffer()
   // and GetCurrentXXXDecoderConfig() must be called to update the current
   // config. GetNextBuffer() must not be called again until
   // GetCurrentXXXDecoderConfig() has been called.
   bool config_change_pending_;
 
   // Used by HandleNextBufferWithSplice() or HandleNextBufferWithPreroll() when
   // a splice frame buffer or buffer with preroll is returned from
   // GetNextBufferInternal().
   scoped_refptr<StreamParserBuffer> pending_buffer_;
 
   // Indicates which of the splice buffers in |splice_buffer_| should be
   // handled out next.
   size_t splice_buffers_index_;
 
   // Indicates that all buffers before |pending_buffer_| have been handed out.
   bool pending_buffers_complete_;
 
   // Indicates that splice frame generation is enabled.
   const bool splice_frames_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceBufferStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_