Switch to standard integer types in media/.

media/cast/sender/video_encoder_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 <vector>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 147 matching lines @@
     }
     PopulateVideoFrame(frame.get(), 123);
     return frame;
   }
 
   // Requests encoding the |video_frame| and has the resulting frame delivered
   // via a callback that checks for expected results.  Returns false if the
   // encoder rejected the request.
   bool EncodeAndCheckDelivery(
       const scoped_refptr<media::VideoFrame>& video_frame,
-      uint32 frame_id,
-      uint32 reference_frame_id) {
+      uint32_t frame_id,
+      uint32_t reference_frame_id) {
     return video_encoder_->EncodeVideoFrame(
         video_frame,
         Now(),
         base::Bind(&VideoEncoderTest::DeliverEncodedVideoFrame,
                    base::Unretained(this),
                    frame_id,
                    reference_frame_id,
                    TimeDeltaToRtpDelta(video_frame->timestamp(),
                                        kVideoFrequency),
                    Now()));
@@ skipping 26 matching lines @@
                 operational_status_ == STATUS_INITIALIZED);
 
     // Create the VideoFrameFactory the first time status changes to
     // STATUS_INITIALIZED.
     if (operational_status_ == STATUS_INITIALIZED && !video_frame_factory_)
       video_frame_factory_ = video_encoder_->CreateVideoFrameFactory().Pass();
   }
 
   // Checks that |encoded_frame| matches expected values.  This is the method
   // bound in the callback returned from EncodeAndCheckDelivery().
-  void DeliverEncodedVideoFrame(
-      uint32 expected_frame_id,
-      uint32 expected_last_referenced_frame_id,
-      uint32 expected_rtp_timestamp,
-      const base::TimeTicks& expected_reference_time,
-      scoped_ptr<SenderEncodedFrame> encoded_frame) {
+  void DeliverEncodedVideoFrame(uint32_t expected_frame_id,
+                                uint32_t expected_last_referenced_frame_id,
+                                uint32_t expected_rtp_timestamp,
+                                const base::TimeTicks& expected_reference_time,
+                                scoped_ptr<SenderEncodedFrame> encoded_frame) {
     EXPECT_TRUE(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
     EXPECT_EQ(expected_frame_id, encoded_frame->frame_id);
     EXPECT_EQ(expected_rtp_timestamp, encoded_frame->rtp_timestamp);
     EXPECT_EQ(expected_reference_time, encoded_frame->reference_time);
 
     // The platform encoders are "black boxes" and may choose to vend key frames
     // and/or empty data at any time.  The software encoders, however, should
     // strictly adhere to expected behavior.
     if (is_testing_platform_encoder()) {
@@ skipping 46 matching lines @@
 
 // A simple test to encode ten frames of video, expecting to see one key frame
 // followed by nine delta frames.
 TEST_P(VideoEncoderTest, GeneratesKeyFrameThenOnlyDeltaFrames) {
   CreateEncoder();
   SetVEAFactoryAutoRespond(true);
 
   EXPECT_EQ(0, count_frames_delivered());
   ExpectVEAResponsesForExternalVideoEncoder(0, 0);
 
-  uint32 frame_id = 0;
-  uint32 reference_frame_id = 0;
+  uint32_t frame_id = 0;
+  uint32_t reference_frame_id = 0;
   const gfx::Size frame_size(1280, 720);
 
   // Some encoders drop one or more frames initially while the encoder
   // initializes. Then, for all encoders, expect one key frame is delivered.
   bool accepted_first_frame = false;
   do {
     accepted_first_frame = EncodeAndCheckDelivery(
         CreateTestVideoFrame(frame_size), frame_id, reference_frame_id);
     if (!encoder_has_resize_delay())
       EXPECT_TRUE(accepted_first_frame);
@@ skipping 30 matching lines @@
   frame_sizes.push_back(gfx::Size(300, 200));  // Shrink both dimensions again.
   frame_sizes.push_back(gfx::Size(200, 300));  // Same area.
   frame_sizes.push_back(gfx::Size(600, 400));  // Grow both dimensions.
   frame_sizes.push_back(gfx::Size(638, 400));  // Shrink only one dimension.
   frame_sizes.push_back(gfx::Size(638, 398));  // Shrink the other dimension.
   frame_sizes.push_back(gfx::Size(320, 180));  // Shrink both dimensions again.
   frame_sizes.push_back(gfx::Size(322, 180));  // Grow only one dimension.
   frame_sizes.push_back(gfx::Size(322, 182));  // Grow the other dimension.
   frame_sizes.push_back(gfx::Size(1920, 1080));  // Grow both dimensions again.
 
-  uint32 frame_id = 0;
+  uint32_t frame_id = 0;
 
   // Encode one frame at each size. For encoders with a resize delay, except no
   // frames to be delivered since each frame size change will sprun
   // re-initialization of the underlying encoder. Otherwise expect all key
   // frames to come out.
   for (const auto& frame_size : frame_sizes) {
     EXPECT_EQ(!encoder_has_resize_delay(),
               EncodeAndCheckDelivery(CreateTestVideoFrame(frame_size), frame_id,
                                      frame_id));
     RunTasksAndAdvanceClock();
@@ skipping 68 matching lines @@
 #endif
   return values;
 }
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(
     , VideoEncoderTest, ::testing::ValuesIn(DetermineEncodersToTest()));
 
 }  // namespace cast
 }  // namespace media