Switch to standard integer types in media/.

media/cast/sender/h264_vt_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 <queue>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_monitor.h"
@@ skipping 66 matching lines @@
                            OperationalStatus in_status) {
   *out_status = in_status;
 }
 
 class MetadataRecorder : public base::RefCountedThreadSafe<MetadataRecorder> {
  public:
   MetadataRecorder() : count_frames_delivered_(0) {}
 
   int count_frames_delivered() const { return count_frames_delivered_; }
 
-  void PushExpectation(uint32 expected_frame_id,
-                       uint32 expected_last_referenced_frame_id,
-                       uint32 expected_rtp_timestamp,
+  void PushExpectation(uint32_t expected_frame_id,
+                       uint32_t expected_last_referenced_frame_id,
+                       uint32_t expected_rtp_timestamp,
                        const base::TimeTicks& expected_reference_time) {
     expectations_.push(Expectation{expected_frame_id,
                                    expected_last_referenced_frame_id,
                                    expected_rtp_timestamp,
                                    expected_reference_time});
   }
 
   void CompareFrameWithExpected(scoped_ptr<SenderEncodedFrame> encoded_frame) {
     ASSERT_LT(0u, expectations_.size());
     auto e = expectations_.front();
@@ skipping 13 matching lines @@
     ++count_frames_delivered_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<MetadataRecorder>;
   virtual ~MetadataRecorder() {}
 
   int count_frames_delivered_;
 
   struct Expectation {
-    uint32 expected_frame_id;
-    uint32 expected_last_referenced_frame_id;
-    uint32 expected_rtp_timestamp;
+    uint32_t expected_frame_id;
+    uint32_t expected_last_referenced_frame_id;
+    uint32_t expected_rtp_timestamp;
     base::TimeTicks expected_reference_time;
   };
   std::queue<Expectation> expectations_;
 
   DISALLOW_COPY_AND_ASSIGN(MetadataRecorder);
 };
 
 class EndToEndFrameChecker
     : public base::RefCountedThreadSafe<EndToEndFrameChecker> {
  public:
@@ skipping 149 matching lines @@
   scoped_refptr<MetadataRecorder> metadata_recorder(new MetadataRecorder());
   VideoEncoder::FrameEncodedCallback cb = base::Bind(
       &MetadataRecorder::CompareFrameWithExpected, metadata_recorder.get());
 
   metadata_recorder->PushExpectation(
       0, 0, TimeDeltaToRtpDelta(frame_->timestamp(), kVideoFrequency),
       clock_->NowTicks());
   EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
   message_loop_.RunUntilIdle();
 
-  for (uint32 frame_id = 1; frame_id < 10; ++frame_id) {
+  for (uint32_t frame_id = 1; frame_id < 10; ++frame_id) {
     AdvanceClockAndVideoFrameTimestamp();
     metadata_recorder->PushExpectation(
         frame_id, frame_id - 1,
         TimeDeltaToRtpDelta(frame_->timestamp(), kVideoFrequency),
         clock_->NowTicks());
     EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
   }
 
   encoder_.reset();
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(10, metadata_recorder->count_frames_delivered());
 }
 
 #if defined(USE_PROPRIETARY_CODECS)
 TEST_F(H264VideoToolboxEncoderTest, CheckFramesAreDecodable) {
   VideoDecoderConfig config(kCodecH264, H264PROFILE_MAIN, frame_->format(),
                             COLOR_SPACE_UNSPECIFIED, frame_->coded_size(),
                             frame_->visible_rect(), frame_->natural_size(),
                             EmptyExtraData(), false);
   scoped_refptr<EndToEndFrameChecker> checker(new EndToEndFrameChecker(config));
 
   VideoEncoder::FrameEncodedCallback cb =
       base::Bind(&EndToEndFrameChecker::EncodeDone, checker.get());
-  for (uint32 frame_id = 0; frame_id < 6; ++frame_id) {
+  for (uint32_t frame_id = 0; frame_id < 6; ++frame_id) {
     checker->PushExpectation(frame_);
     EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
     AdvanceClockAndVideoFrameTimestamp();
   }
 
   encoder_.reset();
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(5, checker->count_frames_checked());
 }
@@ skipping 78 matching lines @@
       gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
 
   // After a power resume event, the factory should produce frames right away
   // because the encoder re-initializes on its own.
   power_source_->GenerateResumeEvent();
   CreateFrameAndMemsetPlane(video_frame_factory.get());
 }
 
 }  // namespace cast
 }  // namespace media