Replace size_t with int in a few media classes.

media/audio/linux/alsa_output.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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 355 matching lines @@
     // Before making a request to source for data we need to determine the
     // delay (in bytes) for the requested data to be played.
 
     uint32 buffer_delay = buffer_->forward_bytes() * bytes_per_frame_ /
         bytes_per_output_frame_;
 
     uint32 hardware_delay = GetCurrentDelay() * bytes_per_frame_;
 
     scoped_refptr<media::DataBuffer> packet =
         new media::DataBuffer(packet_size_);
-    size_t packet_size = RunDataCallback(packet->GetWritableData(),
-                                         packet->GetBufferSize(),
-                                         AudioBuffersState(buffer_delay,
-                                                           hardware_delay));
-    CHECK(packet_size <= packet->GetBufferSize());
+    int packet_size = RunDataCallback(packet->GetWritableData(),
+                                      packet->GetBufferSize(),
+                                      AudioBuffersState(buffer_delay,
+                                                        hardware_delay));
+    CHECK_LE(packet_size, packet->GetBufferSize());
 
     // This should not happen, but in case it does, drop any trailing bytes
     // that aren't large enough to make a frame.  Without this, packet writing
     // may stall because the last few bytes in the packet may never get used by
     // WritePacket.
     DCHECK(packet_size % bytes_per_frame_ == 0);
     packet_size = (packet_size / bytes_per_frame_) * bytes_per_frame_;
 
     if (should_downmix_) {
       if (media::FoldChannels(packet->GetWritableData(),
@@ skipping 32 matching lines @@
     buffer_->Clear();
     return;
   }
 
   if (state() == kIsStopped)
     return;
 
   CHECK_EQ(buffer_->forward_bytes() % bytes_per_output_frame_, 0u);
 
   const uint8* buffer_data;
-  size_t buffer_size;
+  int buffer_size;
   if (buffer_->GetCurrentChunk(&buffer_data, &buffer_size)) {
     buffer_size = buffer_size - (buffer_size % bytes_per_output_frame_);
     snd_pcm_sframes_t frames = buffer_size / bytes_per_output_frame_;
 
     DCHECK_GT(frames, 0);
 
     snd_pcm_sframes_t frames_written =
         wrapper_->PcmWritei(playback_handle_, buffer_data, frames);
     if (frames_written < 0) {
       // Attempt once to immediately recover from EINTR,
@@ skipping 346 matching lines @@
   if (source_callback_)
     source_callback_->OnError(this, code);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK(IsOnAudioThread());
   source_callback_ = callback;
 }