Switch to standard integer types in media/.

media/capture/video/fake_video_capture_device_unittest.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
@@ skipping 14 matching lines @@
 namespace media {
 
 namespace {
 
 // This class is a Client::Buffer that allocates and frees the requested |size|.
 class MockBuffer : public VideoCaptureDevice::Client::Buffer {
  public:
   MockBuffer(int buffer_id, size_t mapped_size)
       : id_(buffer_id),
         mapped_size_(mapped_size),
-        data_(new uint8[mapped_size]) {}
+        data_(new uint8_t[mapped_size]) {}
   ~MockBuffer() override { delete[] data_; }
 
   int id() const override { return id_; }
   gfx::Size dimensions() const override { return gfx::Size(); }
   size_t mapped_size() const override { return mapped_size_; }
   void* data(int plane) override { return data_; }
   ClientBuffer AsClientBuffer(int plane) override { return nullptr; }
 #if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
   base::FileDescriptor AsPlatformFile() override {
     return base::FileDescriptor();
   }
 #endif
 
  private:
   const int id_;
   const size_t mapped_size_;
-  uint8* const data_;
+  uint8_t* const data_;
 };
 
 class MockClient : public VideoCaptureDevice::Client {
  public:
   MOCK_METHOD2(OnError,
                void(const tracked_objects::Location& from_here,
                     const std::string& reason));
 
   explicit MockClient(base::Callback<void(const VideoCaptureFormat&)> frame_cb)
       : frame_cb_(frame_cb) {}
 
   // Client virtual methods for capturing using Device Buffers.
-  void OnIncomingCapturedData(const uint8* data,
+  void OnIncomingCapturedData(const uint8_t* data,
                               int length,
                               const VideoCaptureFormat& format,
                               int rotation,
                               const base::TimeTicks& timestamp) {
     frame_cb_.Run(format);
   }
-  void OnIncomingCapturedYuvData(const uint8* y_data,
-                                 const uint8* u_data,
-                                 const uint8* v_data,
+  void OnIncomingCapturedYuvData(const uint8_t* y_data,
+                                 const uint8_t* u_data,
+                                 const uint8_t* v_data,
                                  size_t y_stride,
                                  size_t u_stride,
                                  size_t v_stride,
                                  const VideoCaptureFormat& frame_format,
                                  int clockwise_rotation,
                                  const base::TimeTicks& timestamp) {
     frame_cb_.Run(frame_format);
   }
 
   // Virtual methods for capturing using Client's Buffers.
@@ skipping 193 matching lines @@
   }
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         FakeVideoCaptureDeviceCommandLineTest,
                         Values(CommandLineTestData{"fps=-1", 5},
                                CommandLineTestData{"fps=29.97", 29.97f},
                                CommandLineTestData{"fps=60", 60},
                                CommandLineTestData{"fps=1000", 60}));
 };  // namespace media