Switch to standard integer types in media/.

media/cast/sender/audio_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 <stdint.h>
 
 #include <sstream>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 28 matching lines @@
     upper_bound_ = upper_bound;
   }
 
   void SetSamplesPerFrame(int samples_per_frame) {
     samples_per_frame_ = samples_per_frame;
   }
 
   void FrameEncoded(scoped_ptr<SenderEncodedFrame> encoded_frame,
                     int samples_skipped) {
     EXPECT_EQ(encoded_frame->dependency, EncodedFrame::KEY);
-    EXPECT_EQ(static_cast<uint8>(frames_received_ & 0xff),
+    EXPECT_EQ(static_cast<uint8_t>(frames_received_ & 0xff),
               encoded_frame->frame_id);
     EXPECT_EQ(encoded_frame->frame_id, encoded_frame->referenced_frame_id);
     // RTP timestamps should be monotonically increasing and integer multiples
     // of the fixed frame size.
     EXPECT_LE(rtp_lower_bound_, encoded_frame->rtp_timestamp);
     rtp_lower_bound_ = encoded_frame->rtp_timestamp;
     EXPECT_EQ(0u, encoded_frame->rtp_timestamp % samples_per_frame_);
     EXPECT_TRUE(!encoded_frame->data.empty());
 
     EXPECT_LE(lower_bound_, encoded_frame->reference_time);
     lower_bound_ = encoded_frame->reference_time;
     EXPECT_GT(upper_bound_, encoded_frame->reference_time);
 
     EXPECT_LE(0.0, encoded_frame->deadline_utilization);
     EXPECT_EQ(-1.0, encoded_frame->lossy_utilization);
 
     ++frames_received_;
   }
 
  private:
   int frames_received_;
-  uint32 rtp_lower_bound_;
+  uint32_t rtp_lower_bound_;
   int samples_per_frame_;
   base::TimeTicks lower_bound_;
   base::TimeTicks upper_bound_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEncodedAudioFrameReceiver);
 };
 
 struct TestScenario {
-  const int64* durations_in_ms;
+  const int64_t* durations_in_ms;
   size_t num_durations;
 
-  TestScenario(const int64* d, size_t n)
+  TestScenario(const int64_t* d, size_t n)
       : durations_in_ms(d), num_durations(n) {}
 
   std::string ToString() const {
     std::ostringstream out;
     for (size_t i = 0; i < num_durations; ++i) {
       if (i > 0)
         out << ", ";
       out << durations_in_ms[i];
     }
     return out.str();
@@ skipping 90 matching lines @@
 TEST_P(AudioEncoderTest, EncodePcm16) {
   RunTestForCodec(CODEC_AUDIO_PCM16);
 }
 
 #if defined(OS_MACOSX)
 TEST_P(AudioEncoderTest, EncodeAac) {
   RunTestForCodec(CODEC_AUDIO_AAC);
 }
 #endif
 
-static const int64 kOneCall_3Millis[] = {3};
-static const int64 kOneCall_10Millis[] = {10};
-static const int64 kOneCall_13Millis[] = {13};
-static const int64 kOneCall_20Millis[] = {20};
+static const int64_t kOneCall_3Millis[] = {3};
+static const int64_t kOneCall_10Millis[] = {10};
+static const int64_t kOneCall_13Millis[] = {13};
+static const int64_t kOneCall_20Millis[] = {20};
 
-static const int64 kTwoCalls_3Millis[] = {3, 3};
-static const int64 kTwoCalls_10Millis[] = {10, 10};
-static const int64 kTwoCalls_Mixed1[] = {3, 10};
-static const int64 kTwoCalls_Mixed2[] = {10, 3};
-static const int64 kTwoCalls_Mixed3[] = {3, 17};
-static const int64 kTwoCalls_Mixed4[] = {17, 3};
+static const int64_t kTwoCalls_3Millis[] = {3, 3};
+static const int64_t kTwoCalls_10Millis[] = {10, 10};
+static const int64_t kTwoCalls_Mixed1[] = {3, 10};
+static const int64_t kTwoCalls_Mixed2[] = {10, 3};
+static const int64_t kTwoCalls_Mixed3[] = {3, 17};
+static const int64_t kTwoCalls_Mixed4[] = {17, 3};
 
-static const int64 kManyCalls_3Millis[] = {3, 3, 3, 3, 3, 3, 3, 3,
-                                           3, 3, 3, 3, 3, 3, 3};
-static const int64 kManyCalls_10Millis[] = {10, 10, 10, 10, 10, 10, 10, 10,
-                                            10, 10, 10, 10, 10, 10, 10};
-static const int64 kManyCalls_Mixed1[] = {3,  10, 3,  10, 3,  10, 3,  10, 3,
-                                          10, 3,  10, 3,  10, 3,  10, 3,  10};
-static const int64 kManyCalls_Mixed2[] = {10, 3, 10, 3, 10, 3, 10, 3, 10, 3,
-                                          10, 3, 10, 3, 10, 3, 10, 3, 10, 3};
-static const int64 kManyCalls_Mixed3[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8,
-                                          9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6, 4};
-static const int64 kManyCalls_Mixed4[] = {31, 4, 15, 9,  26, 53, 5,  8, 9,
-                                          7,  9, 32, 38, 4,  62, 64, 3};
-static const int64 kManyCalls_Mixed5[] = {3, 14, 15, 9, 26, 53, 58, 9, 7,
-                                          9, 3,  23, 8, 4,  6,  2,  6, 43};
+static const int64_t kManyCalls_3Millis[] = {3, 3, 3, 3, 3, 3, 3, 3,
+                                             3, 3, 3, 3, 3, 3, 3};
+static const int64_t kManyCalls_10Millis[] = {10, 10, 10, 10, 10, 10, 10, 10,
+                                              10, 10, 10, 10, 10, 10, 10};
+static const int64_t kManyCalls_Mixed1[] = {3,  10, 3,  10, 3,  10, 3,  10, 3,
+                                            10, 3,  10, 3,  10, 3,  10, 3,  10};
+static const int64_t kManyCalls_Mixed2[] = {10, 3, 10, 3, 10, 3, 10, 3, 10, 3,
+                                            10, 3, 10, 3, 10, 3, 10, 3, 10, 3};
+static const int64_t kManyCalls_Mixed3[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8,
+                                            9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6, 4};
+static const int64_t kManyCalls_Mixed4[] = {31, 4, 15, 9,  26, 53, 5,  8, 9,
+                                            7,  9, 32, 38, 4,  62, 64, 3};
+static const int64_t kManyCalls_Mixed5[] = {3, 14, 15, 9, 26, 53, 58, 9, 7,
+                                            9, 3,  23, 8, 4,  6,  2,  6, 43};
 
-static const int64 kOneBigUnderrun[] = {10, 10, 10, 10, -1000, 10, 10, 10};
-static const int64 kTwoBigUnderruns[] = {10, 10, 10, 10, -712, 10, 10, 10,
-                                         -1311, 10, 10, 10};
-static const int64 kMixedUnderruns[] = {31, -64, 4, 15, 9, 26, -53, 5,  8, -9,
-                                        7,  9, 32, 38, -4, 62, -64, 3};
+static const int64_t kOneBigUnderrun[] = {10, 10, 10, 10, -1000, 10, 10, 10};
+static const int64_t kTwoBigUnderruns[] = {10, 10, 10,    10, -712, 10,
+                                           10, 10, -1311, 10, 10,   10};
+static const int64_t kMixedUnderruns[] = {31, -64, 4, 15, 9,  26, -53, 5,   8,
+                                          -9, 7,   9, 32, 38, -4, 62,  -64, 3};
 
 INSTANTIATE_TEST_CASE_P(
     AudioEncoderTestScenarios,
     AudioEncoderTest,
     ::testing::Values(
         TestScenario(kOneCall_3Millis, arraysize(kOneCall_3Millis)),
         TestScenario(kOneCall_10Millis, arraysize(kOneCall_10Millis)),
         TestScenario(kOneCall_13Millis, arraysize(kOneCall_13Millis)),
         TestScenario(kOneCall_20Millis, arraysize(kOneCall_20Millis)),
         TestScenario(kTwoCalls_3Millis, arraysize(kTwoCalls_3Millis)),
         TestScenario(kTwoCalls_10Millis, arraysize(kTwoCalls_10Millis)),
         TestScenario(kTwoCalls_Mixed1, arraysize(kTwoCalls_Mixed1)),
         TestScenario(kTwoCalls_Mixed2, arraysize(kTwoCalls_Mixed2)),
         TestScenario(kTwoCalls_Mixed3, arraysize(kTwoCalls_Mixed3)),
         TestScenario(kTwoCalls_Mixed4, arraysize(kTwoCalls_Mixed4)),
         TestScenario(kManyCalls_3Millis, arraysize(kManyCalls_3Millis)),
         TestScenario(kManyCalls_10Millis, arraysize(kManyCalls_10Millis)),
         TestScenario(kManyCalls_Mixed1, arraysize(kManyCalls_Mixed1)),
         TestScenario(kManyCalls_Mixed2, arraysize(kManyCalls_Mixed2)),
         TestScenario(kManyCalls_Mixed3, arraysize(kManyCalls_Mixed3)),
         TestScenario(kManyCalls_Mixed4, arraysize(kManyCalls_Mixed4)),
         TestScenario(kManyCalls_Mixed5, arraysize(kManyCalls_Mixed5)),
         TestScenario(kOneBigUnderrun, arraysize(kOneBigUnderrun)),
         TestScenario(kTwoBigUnderruns, arraysize(kTwoBigUnderruns)),
         TestScenario(kMixedUnderruns, arraysize(kMixedUnderruns))));
 
 }  // namespace cast
 }  // namespace media