Switch to standard integer types in media/.

media/cast/receiver/video_decoder.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 "media/cast/receiver/video_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
@@ skipping 31 matching lines @@
   }
 
   void DecodeFrame(scoped_ptr<EncodedFrame> encoded_frame,
                    const DecodeFrameCallback& callback) {
     DCHECK_EQ(operational_status_, STATUS_INITIALIZED);
 
     static_assert(sizeof(encoded_frame->frame_id) == sizeof(last_frame_id_),
                   "size of frame_id types do not match");
     bool is_continuous = true;
     if (seen_first_frame_) {
-      const uint32 frames_ahead = encoded_frame->frame_id - last_frame_id_;
+      const uint32_t frames_ahead = encoded_frame->frame_id - last_frame_id_;
       if (frames_ahead > 1) {
         RecoverBecauseFramesWereDropped();
         is_continuous = false;
       }
     } else {
       seen_first_frame_ = true;
     }
     last_frame_id_ = encoded_frame->frame_id;
 
     const scoped_refptr<VideoFrame> decoded_frame = Decode(
@@ skipping 14 matching lines @@
         base::Bind(callback, decoded_frame, is_continuous));
   }
 
  protected:
   friend class base::RefCountedThreadSafe<ImplBase>;
   virtual ~ImplBase() {}
 
   virtual void RecoverBecauseFramesWereDropped() {}
 
   // Note: Implementation of Decode() is allowed to mutate |data|.
-  virtual scoped_refptr<VideoFrame> Decode(uint8* data, int len) = 0;
+  virtual scoped_refptr<VideoFrame> Decode(uint8_t* data, int len) = 0;
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const Codec codec_;
 
   // Subclass' ctor is expected to set this to STATUS_INITIALIZED.
   OperationalStatus operational_status_;
 
   // Pool of VideoFrames to decode incoming frames into.
   media::VideoFramePool video_frame_pool_;
 
  private:
   bool seen_first_frame_;
-  uint32 last_frame_id_;
+  uint32_t last_frame_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImplBase);
 };
 
 class VideoDecoder::Vp8Impl : public VideoDecoder::ImplBase {
  public:
   explicit Vp8Impl(const scoped_refptr<CastEnvironment>& cast_environment)
       : ImplBase(cast_environment, CODEC_VIDEO_VP8) {
     if (ImplBase::operational_status_ != STATUS_UNINITIALIZED)
       return;
@@ skipping 13 matching lines @@
     }
     ImplBase::operational_status_ = STATUS_INITIALIZED;
   }
 
  private:
   ~Vp8Impl() final {
     if (ImplBase::operational_status_ == STATUS_INITIALIZED)
       CHECK_EQ(VPX_CODEC_OK, vpx_codec_destroy(&context_));
   }
 
-  scoped_refptr<VideoFrame> Decode(uint8* data, int len) final {
+  scoped_refptr<VideoFrame> Decode(uint8_t* data, int len) final {
     if (len <= 0 || vpx_codec_decode(&context_,
                                      data,
                                      static_cast<unsigned int>(len),
                                      NULL,
                                      0) != VPX_CODEC_OK) {
       return NULL;
     }
 
     vpx_codec_iter_t iter = NULL;
     vpx_image_t* const image = vpx_codec_get_frame(&context_, &iter);
@@ skipping 41 matching lines @@
       : ImplBase(cast_environment, CODEC_VIDEO_FAKE),
         last_decoded_id_(-1) {
     if (ImplBase::operational_status_ != STATUS_UNINITIALIZED)
       return;
     ImplBase::operational_status_ = STATUS_INITIALIZED;
   }
 
  private:
   ~FakeImpl() final {}
 
-  scoped_refptr<VideoFrame> Decode(uint8* data, int len) final {
+  scoped_refptr<VideoFrame> Decode(uint8_t* data, int len) final {
     // Make sure this is a JSON string.
     if (!len || data[0] != '{')
       return NULL;
     base::JSONReader reader;
     scoped_ptr<base::Value> values(
         reader.Read(base::StringPiece(reinterpret_cast<char*>(data), len)));
     if (!values)
       return NULL;
     base::DictionaryValue* dict = NULL;
     values->GetAsDictionary(&dict);
@@ skipping 58 matching lines @@
   cast_environment_->PostTask(CastEnvironment::VIDEO,
                               FROM_HERE,
                               base::Bind(&VideoDecoder::ImplBase::DecodeFrame,
                                          impl_,
                                          base::Passed(&encoded_frame),
                                          callback));
 }
 
 }  // namespace cast
 }  // namespace media