Replace size_t with int in a few media classes.

This addressed TODOs in DataSource::Read() and AudioRendererAlgorithmBase, which led to converting Buffer and SeekableBuffer as well.

Review URL: https://chromiumcodereview.appspot.com/9854031

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@129140 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 22 insertions, 26 deletions

diff --git a/webkit/media/buffered_data_source.cc b/webkit/media/buffered_data_source.cc
index 1d39684..a5e94bd 100644
--- a/webkit/media/buffered_data_source.cc
+++ b/webkit/media/buffered_data_source.cc
@@ -139,7 +139,7 @@ void BufferedDataSource::SetBitrate(int bitrate) {
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Read(
-    int64 position, size_t size, uint8* data,
+    int64 position, int size, uint8* data,
     const media::DataSource::ReadCB& read_cb) {
   DVLOG(1) << "Read: " << position << " offset, " << size << " bytes";
   DCHECK(!read_cb.is_null());
@@ -157,8 +157,7 @@ void BufferedDataSource::Read(
   }
 
   render_loop_->PostTask(FROM_HERE, base::Bind(
-      &BufferedDataSource::ReadTask, this,
-      position, static_cast<int>(size), data));
+      &BufferedDataSource::ReadTask, this, position, size, data));
 }
 
 bool BufferedDataSource::GetSize(int64* size_out) {
@@ -334,7 +333,7 @@ void BufferedDataSource::DoneRead_Locked(int error) {
   lock_.AssertAcquired();
 
   if (error >= 0) {
-    read_cb_.Run(static_cast<size_t>(error));
+    read_cb_.Run(error);
   } else {
     read_cb_.Run(kReadError);
   }
diff --git a/webkit/media/buffered_data_source.h b/webkit/media/buffered_data_source.h
index e9d979e..9935c51 100644
--- a/webkit/media/buffered_data_source.h
+++ b/webkit/media/buffered_data_source.h
@@ -36,11 +36,8 @@ class BufferedDataSource : public WebDataSource {
   virtual void Stop(const base::Closure& closure) OVERRIDE;
   virtual void SetPlaybackRate(float playback_rate) OVERRIDE;
 
-  virtual void Read(
-      int64 position,
-      size_t size,
-      uint8* data,
-      const media::DataSource::ReadCB& read_cb) OVERRIDE;
+  virtual void Read(int64 position, int size, uint8* data,
+                    const media::DataSource::ReadCB& read_cb) OVERRIDE;
   virtual bool GetSize(int64* size_out) OVERRIDE;
   virtual bool IsStreaming() OVERRIDE;
   virtual void SetPreload(media::Preload preload) OVERRIDE;
diff --git a/webkit/media/buffered_data_source_unittest.cc b/webkit/media/buffered_data_source_unittest.cc
index 982e47b..eecadfe 100644
--- a/webkit/media/buffered_data_source_unittest.cc
+++ b/webkit/media/buffered_data_source_unittest.cc
@@ -72,7 +72,7 @@ class MockBufferedDataSource : public BufferedDataSource {
 
 static const int64 kFileSize = 5000000;
 static const int64 kFarReadPosition = 4000000;
-static const size_t kDataSize = 1024;
+static const int kDataSize = 1024;
 
 class BufferedDataSourceTest : public testing::Test {
  public:
@@ -144,7 +144,7 @@ class BufferedDataSourceTest : public testing::Test {
     message_loop_->RunAllPending();
   }
 
-  MOCK_METHOD1(ReadCallback, void(size_t size));
+  MOCK_METHOD1(ReadCallback, void(int size));
 
   void ReadAt(int64 position) {
     data_source_->Read(position, kDataSize, buffer_,
diff --git a/webkit/media/buffered_resource_loader_unittest.cc b/webkit/media/buffered_resource_loader_unittest.cc
index b995268..6073df2 100644
--- a/webkit/media/buffered_resource_loader_unittest.cc
+++ b/webkit/media/buffered_resource_loader_unittest.cc
@@ -89,7 +89,7 @@ class BufferedResourceLoaderTest : public testing::Test {
     loader_->SetURLLoaderForTest(scoped_ptr<WebKit::WebURLLoader>(url_loader_));
   }
 
-  void SetLoaderBuffer(size_t forward_capacity, size_t backward_capacity) {
+  void SetLoaderBuffer(int forward_capacity, int backward_capacity) {
     loader_->buffer_.reset(
         new media::SeekableBuffer(backward_capacity, forward_capacity));
   }
@@ -213,8 +213,8 @@ class BufferedResourceLoaderTest : public testing::Test {
   }
 
   void WriteUntilThreshold() {
-    size_t buffered = loader_->buffer_->forward_bytes();
-    size_t capacity = loader_->buffer_->forward_capacity();
+    int buffered = loader_->buffer_->forward_bytes();
+    int capacity = loader_->buffer_->forward_capacity();
     CHECK_LT(buffered, capacity);
 
     EXPECT_CALL(*this, NetworkCallback());
@@ -242,22 +242,22 @@ class BufferedResourceLoaderTest : public testing::Test {
     EXPECT_EQ(loader_->last_offset_, expected_last_offset);
   }
 
-  void ConfirmBufferState(size_t backward_bytes,
-                          size_t backward_capacity,
-                          size_t forward_bytes,
-                          size_t forward_capacity) {
+  void ConfirmBufferState(int backward_bytes,
+                          int backward_capacity,
+                          int forward_bytes,
+                          int forward_capacity) {
     EXPECT_EQ(backward_bytes, loader_->buffer_->backward_bytes());
     EXPECT_EQ(backward_capacity, loader_->buffer_->backward_capacity());
     EXPECT_EQ(forward_bytes, loader_->buffer_->forward_bytes());
     EXPECT_EQ(forward_capacity, loader_->buffer_->forward_capacity());
   }
 
-  void ConfirmLoaderBufferBackwardCapacity(size_t expected_backward_capacity) {
+  void ConfirmLoaderBufferBackwardCapacity(int expected_backward_capacity) {
     EXPECT_EQ(loader_->buffer_->backward_capacity(),
               expected_backward_capacity);
   }
 
-  void ConfirmLoaderBufferForwardCapacity(size_t expected_forward_capacity) {
+  void ConfirmLoaderBufferForwardCapacity(int expected_forward_capacity) {
     EXPECT_EQ(loader_->buffer_->forward_capacity(), expected_forward_capacity);
   }
 
@@ -268,12 +268,12 @@ class BufferedResourceLoaderTest : public testing::Test {
   // Makes sure the |loader_| buffer window is in a reasonable range.
   void CheckBufferWindowBounds() {
     // Corresponds to value defined in buffered_resource_loader.cc.
-    static const size_t kMinBufferCapacity = 2 * 1024 * 1024;
+    static const int kMinBufferCapacity = 2 * 1024 * 1024;
     EXPECT_GE(loader_->buffer_->forward_capacity(), kMinBufferCapacity);
     EXPECT_GE(loader_->buffer_->backward_capacity(), kMinBufferCapacity);
 
     // Corresponds to value defined in buffered_resource_loader.cc.
-    static const size_t kMaxBufferCapacity = 20 * 1024 * 1024;
+    static const int kMaxBufferCapacity = 20 * 1024 * 1024;
     EXPECT_LE(loader_->buffer_->forward_capacity(), kMaxBufferCapacity);
     EXPECT_LE(loader_->buffer_->backward_capacity(), kMaxBufferCapacity);
   }
@@ -283,8 +283,8 @@ class BufferedResourceLoaderTest : public testing::Test {
   MOCK_METHOD0(NetworkCallback, void());
 
   // Accessors for private variables on |loader_|.
-  size_t forward_bytes() { return loader_->buffer_->forward_bytes(); }
-  size_t forward_capacity() { return loader_->buffer_->forward_capacity(); }
+  int forward_bytes() { return loader_->buffer_->forward_bytes(); }
+  int forward_capacity() { return loader_->buffer_->forward_capacity(); }
 
  protected:
   GURL gurl_;
@@ -943,8 +943,8 @@ TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadBackwards) {
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_ReadPastThreshold) {
-  const size_t kSize = 5 * 1024 * 1024;
-  const size_t kThreshold = 2 * 1024 * 1024;
+  const int kSize = 5 * 1024 * 1024;
+  const int kThreshold = 2 * 1024 * 1024;
 
   Initialize(kHttpUrl, 10, kSize);
   SetLoaderBuffer(10, 10);