Switch to standard integer types in media/.

media/cast/sender/video_sender_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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 12 matching lines @@
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/video/fake_video_encode_accelerator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 namespace {
-static const uint8 kPixelValue = 123;
+static const uint8_t kPixelValue = 123;
 static const int kWidth = 320;
 static const int kHeight = 240;
 
 using testing::_;
 using testing::AtLeast;
 
 
 void SaveOperationalStatus(OperationalStatus* out_status,
                            OperationalStatus in_status) {
   DVLOG(1) << "OperationalStatus transitioning from " << *out_status << " to "
@@ skipping 22 matching lines @@
       // packet.  This confirms that the receiver will have the necessary lip
       // sync info before it has to calculate the playout time of the first
       // frame.
       if (number_of_rtp_packets_ == 0)
         EXPECT_LE(1, number_of_rtcp_packets_);
       ++number_of_rtp_packets_;
     }
     return true;
   }
 
-  int64 GetBytesSent() final { return 0; }
+  int64_t GetBytesSent() final { return 0; }
 
   int number_of_rtp_packets() const { return number_of_rtp_packets_; }
 
   int number_of_rtcp_packets() const { return number_of_rtcp_packets_; }
 
   void SetPause(bool paused) {
     paused_ = paused;
     if (!paused && stored_packet_.get()) {
       SendPacket(stored_packet_, callback_);
       callback_.Run();
@@ skipping 32 matching lines @@
   using VideoSender::OnReceivedCastFeedback;
   using VideoSender::GetMaximumTargetBitrateForFrame;
 };
 
 // Creates a VideoFrame NOT backed by actual memory storage.  The frame's
 // metadata (i.e., size and frame duration) are all that are needed to test the
 // GetMaximumTargetBitrateForFrame() logic.
 scoped_refptr<VideoFrame> CreateFakeFrame(const gfx::Size& resolution,
                                           bool high_frame_rate_in_metadata) {
   const scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalData(
-      PIXEL_FORMAT_I420,
-      resolution,
-      gfx::Rect(resolution),
-      resolution,
-      static_cast<uint8*>(nullptr) + 1,
-      resolution.GetArea() * 3 / 2,
+      PIXEL_FORMAT_I420, resolution, gfx::Rect(resolution), resolution,
+      static_cast<uint8_t*>(nullptr) + 1, resolution.GetArea() * 3 / 2,
       base::TimeDelta());
   const double frame_rate = high_frame_rate_in_metadata ? 60.0 : 30.0;
   frame->metadata()->SetTimeDelta(
       VideoFrameMetadata::FRAME_DURATION,
       base::TimeDelta::FromSecondsD(1.0 / frame_rate));
   return frame;
 }
 
 }  // namespace
 
@@ skipping 513 matching lines @@
                  << ", hfr=" << kTestCases[i].high_frame_rate);
     const scoped_refptr<VideoFrame> frame =
         CreateFakeFrame(resolution, kTestCases[i].high_frame_rate);
     EXPECT_EQ(kTestCases[i].expected_bitrate,
               PeerVideoSender::GetMaximumTargetBitrateForFrame(*frame));
   }
 }
 
 }  // namespace cast
 }  // namespace media