Switch to standard integer types in media/.

media/capture/video/linux/video_capture_device_factory_linux.cc

 // Copyright 2014 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 "media/capture/video/linux/video_capture_device_factory_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(OS_OPENBSD)
 #include <sys/videoio.h>
 #else
 #include <linux/videodev2.h>
 #endif
 #include <sys/ioctl.h>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_file.h"
 #include "base/posix/eintr_wrapper.h"
 #if defined(OS_CHROMEOS)
 #include "media/capture/video/linux/video_capture_device_chromeos.h"
 #endif
 #include "media/capture/video/linux/video_capture_device_linux.h"
 
 namespace media {
 
-static bool HasUsableFormats(int fd, uint32 capabilities) {
+static bool HasUsableFormats(int fd, uint32_t capabilities) {
   const std::list<uint32_t>& usable_fourccs =
       VideoCaptureDeviceLinux::GetListOfUsableFourCCs(false);
 
   static const struct {
     int capability;
     v4l2_buf_type buf_type;
   } kCapabilityAndBufferTypes[] = {
       {V4L2_CAP_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE},
       {V4L2_CAP_VIDEO_CAPTURE_MPLANE, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE}};
 
   for (const auto& capability_and_buffer_type : kCapabilityAndBufferTypes) {
     v4l2_fmtdesc fmtdesc = {};
     if (capabilities & capability_and_buffer_type.capability) {
       fmtdesc.type = capability_and_buffer_type.buf_type;
       for (; HANDLE_EINTR(ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc)) == 0;
            ++fmtdesc.index) {
         if (std::find(usable_fourccs.begin(), usable_fourccs.end(),
                       fmtdesc.pixelformat) != usable_fourccs.end())
           return true;
       }
     }
   }
   DLOG(ERROR) << "No usable formats found";
   return false;
 }
 
 static std::list<float> GetFrameRateList(int fd,
-                                         uint32 fourcc,
-                                         uint32 width,
-                                         uint32 height) {
+                                         uint32_t fourcc,
+                                         uint32_t width,
+                                         uint32_t height) {
   std::list<float> frame_rates;
 
   v4l2_frmivalenum frame_interval = {};
   frame_interval.pixel_format = fourcc;
   frame_interval.width = width;
   frame_interval.height = height;
   for (; HANDLE_EINTR(ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frame_interval)) ==
              0;
        ++frame_interval.index) {
     if (frame_interval.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
@@ skipping 148 matching lines @@
 }
 
 // static
 VideoCaptureDeviceFactory*
 VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return new VideoCaptureDeviceFactoryLinux(ui_task_runner);
 }
 
 }  // namespace media