Remove kint32max.

content/common/gpu/media/android_video_encode_accelerator.cc

 // Copyright 2013 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 "content/common/gpu/media/android_video_encode_accelerator.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 127 matching lines @@
     profile.max_framerate_denominator = kMaxFramerateDenominator;
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 bool AndroidVideoEncodeAccelerator::Initialize(
     media::VideoPixelFormat format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
-    uint32 initial_bitrate,
+    uint32_t initial_bitrate,
     Client* client) {
   DVLOG(3) << __PRETTY_FUNCTION__ << " format: " << format
            << ", input_visible_size: " << input_visible_size.ToString()
            << ", output_profile: " << output_profile
            << ", initial_bitrate: " << initial_bitrate;
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
 
@@ skipping 102 matching lines @@
   DVLOG(3) << __PRETTY_FUNCTION__ << ": bitstream_buffer_id=" << buffer.id();
   DCHECK(thread_checker_.CalledOnValidThread());
   RETURN_ON_FAILURE(buffer.size() >= media_codec_->GetOutputBuffersCapacity(),
                     "Output buffers too small!",
                     kInvalidArgumentError);
   available_bitstream_buffers_.push_back(buffer);
   DoIOTask();
 }
 
 void AndroidVideoEncodeAccelerator::RequestEncodingParametersChange(
-    uint32 bitrate,
-    uint32 framerate) {
+    uint32_t bitrate,
+    uint32_t framerate) {
   DVLOG(3) << __PRETTY_FUNCTION__ << ": bitrate: " << bitrate
            << ", framerate: " << framerate;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (bitrate != last_set_bitrate_) {
     last_set_bitrate_ = bitrate;
     media_codec_->SetVideoBitrate(bitrate);
   }
   // Note: Android's MediaCodec doesn't allow mid-stream adjustments to
   // framerate, so we ignore that here.  This is OK because Android only uses
   // the framerate value from MediaFormat during configure() as a proxy for
@@ skipping 103 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Media.AVEA.OutputBuffersSuffice", ret);
   return ret;
 }
 
 void AndroidVideoEncodeAccelerator::DequeueOutput() {
   if (!client_ptr_factory_->GetWeakPtr() ||
       available_bitstream_buffers_.empty() || num_buffers_at_codec_ == 0) {
     return;
   }
 
-  int32 buf_index = 0;
+  int32_t buf_index = 0;
   size_t offset = 0;
   size_t size = 0;
   bool key_frame = false;
   do {
     media::MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
         NoWaitTimeOut(), &buf_index, &offset, &size, NULL, NULL, &key_frame);
     switch (status) {
       case media::MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
         return;
 
@@ skipping 39 matching lines @@
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::BitstreamBufferReady,
                  client_ptr_factory_->GetWeakPtr(),
                  bitstream_buffer.id(),
                  size,
                  key_frame));
 }
 
 }  // namespace content