Replace size_t with int in a few media classes.

media/filters/ffmpeg_demuxer_unittest.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 <deque>
 
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "media/base/filters.h"
@@ skipping 85 matching lines @@
     EXPECT_CALL(host_, SetDuration(_));
     demuxer_->Initialize(data_source, NewExpectedStatusCB(PIPELINE_OK));
     message_loop_.RunAllPending();
   }
 
   // Verifies that |buffer| has a specific |size| and |timestamp|.
   // |location| simply indicates where the call to this function was made.
   // This makes it easier to track down where test failures occur.
   void ValidateBuffer(const tracked_objects::Location& location,
                       const scoped_refptr<Buffer>& buffer,
-                      size_t size, int64 timestampInMicroseconds) {
+                      int size, int64 timestampInMicroseconds) {
     std::string location_str;
     location.Write(true, false, &location_str);
     location_str += "\n";
     SCOPED_TRACE(location_str);
     EXPECT_TRUE(buffer.get() != NULL);
     EXPECT_EQ(size, buffer->GetDataSize());
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(timestampInMicroseconds),
               buffer->GetTimestamp());
   }
 
@@ skipping 217 matching lines @@
   const int kMaxBuffers = 170;
   for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
     reader->Read(audio);
     message_loop_.RunAllPending();
     EXPECT_TRUE(reader->called());
     ASSERT_TRUE(reader->buffer());
 
     if (reader->buffer()->IsEndOfStream()) {
       got_eos_buffer = true;
       EXPECT_TRUE(reader->buffer()->GetData() == NULL);
-      EXPECT_EQ(0u, reader->buffer()->GetDataSize());
+      EXPECT_EQ(0, reader->buffer()->GetDataSize());
       break;
     }
 
     EXPECT_TRUE(reader->buffer()->GetData() != NULL);
-    EXPECT_GT(reader->buffer()->GetDataSize(), 0u);
+    EXPECT_GT(reader->buffer()->GetDataSize(), 0);
     reader->Reset();
   }
 
   EXPECT_TRUE(got_eos_buffer);
 }
 
 TEST_F(FFmpegDemuxerTest, Seek) {
   // We're testing that the demuxer frees all queued packets when it receives
   // a Seek().
   InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
@@ skipping 186 matching lines @@
   EXPECT_TRUE(reader->buffer()->IsEndOfStream());
 }
 
 class MockFFmpegDemuxer : public FFmpegDemuxer {
  public:
   explicit MockFFmpegDemuxer(MessageLoop* message_loop)
       : FFmpegDemuxer(message_loop, true) {
   }
   virtual ~MockFFmpegDemuxer() {}
 
-  MOCK_METHOD0(WaitForRead, size_t());
-  MOCK_METHOD1(SignalReadCompleted, void(size_t size));
+  MOCK_METHOD0(WaitForRead, int());
+  MOCK_METHOD1(SignalReadCompleted, void(int size));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockFFmpegDemuxer);
 };
 
 // A gmock helper method to execute the callback and deletes it.
-void RunCallback(size_t size, const DataSource::ReadCB& callback) {
+void RunCallback(int size, const DataSource::ReadCB& callback) {
   DCHECK(!callback.is_null());
   callback.Run(size);
 }
 
 TEST_F(FFmpegDemuxerTest, ProtocolRead) {
   scoped_refptr<StrictMock<MockDataSource> > data_source =
       new StrictMock<MockDataSource>();
 
   EXPECT_CALL(*data_source, Stop(_))
       .WillRepeatedly(Invoke(&RunStopFilterCallback));
@@ skipping 162 matching lines @@
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 1740, 2436000);
 
   // Manually release the last reference to the buffer and verify it was freed.
   reader->Reset();
   message_loop_.RunAllPending();
 }
 
 }  // namespace media