Replace size_t with int in a few media classes.

media/filters/ffmpeg_demuxer.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 22 matching lines @@
         packet_(packet.Pass()) {
   }
 
   virtual ~AVPacketBuffer() {}
 
   // Buffer implementation.
   virtual const uint8* GetData() const {
     return reinterpret_cast<const uint8*>(packet_->data);
   }
 
-  virtual size_t GetDataSize() const {
-    return static_cast<size_t>(packet_->size);
+  virtual int GetDataSize() const {
+    return packet_->size;
   }
 
  private:
   scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet_;
 
   DISALLOW_COPY_AND_ASSIGN(AVPacketBuffer);
 };
 
 
 //
@@ skipping 327 matching lines @@
   if (read_has_failed_)
     return AVERROR(EIO);
 
   // Even though FFmpeg defines AVERROR_EOF, it's not to be used with I/O
   // routines.  Instead return 0 for any read at or past EOF.
   int64 file_size;
   if (data_source_->GetSize(&file_size) && read_position_ >= file_size)
     return 0;
 
   // Asynchronous read from data source.
-  data_source_->Read(read_position_, size, data,
-                     base::Bind(&FFmpegDemuxer::OnReadCompleted, this));
+  data_source_->Read(read_position_, size, data, base::Bind(
+      &FFmpegDemuxer::SignalReadCompleted, this));
 
   // TODO(hclam): The method is called on the demuxer thread and this method
   // call will block the thread. We need to implemented an additional thread to
   // let FFmpeg demuxer methods to run on.
-  size_t last_read_bytes = WaitForRead();
+  int last_read_bytes = WaitForRead();
   if (last_read_bytes == DataSource::kReadError) {
     if (host())
       host()->OnDemuxerError(PIPELINE_ERROR_READ);
     else
       deferred_status_ = PIPELINE_ERROR_READ;
 
     // Returns with a negative number to signal an error to FFmpeg.
     read_has_failed_ = true;
     return AVERROR(EIO);
   }
@@ skipping 317 matching lines @@
     if (!*iter ||
         (audio_disabled_ && (*iter)->type() == DemuxerStream::AUDIO)) {
       continue;
     }
     scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet(new AVPacket());
     memset(packet.get(), 0, sizeof(*packet.get()));
     (*iter)->EnqueuePacket(packet.Pass());
   }
 }
 
-void FFmpegDemuxer::OnReadCompleted(size_t size) {
-  SignalReadCompleted(size);
-}
-
-size_t FFmpegDemuxer::WaitForRead() {
+int FFmpegDemuxer::WaitForRead() {
   read_event_.Wait();
   return last_read_bytes_;
 }
 
-void FFmpegDemuxer::SignalReadCompleted(size_t size) {
+void FFmpegDemuxer::SignalReadCompleted(int size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media