Switch to standard integer types in content/renderer/.

content/renderer/media/pepper_to_video_track_adapter.cc

 // Copyright (c) 2013 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 "content/renderer/media/pepper_to_video_track_adapter.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_registry_interface.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/video_capture_types.h"
@@ skipping 12 matching lines @@
 // Effects plugin) to inject the processed frame.
 class PpFrameWriter : public MediaStreamVideoSource,
                       public FrameWriterInterface,
                       public base::SupportsWeakPtr<PpFrameWriter> {
  public:
   PpFrameWriter();
   ~PpFrameWriter() override;
 
   // FrameWriterInterface implementation.
   // This method will be called by the Pepper host from render thread.
-  void PutFrame(PPB_ImageData_Impl* image_data, int64 time_stamp_ns) override;
+  void PutFrame(PPB_ImageData_Impl* image_data, int64_t time_stamp_ns) override;
 
  protected:
   // MediaStreamVideoSource implementation.
   void GetCurrentSupportedFormats(
       int max_requested_width,
       int max_requested_height,
       double max_requested_frame_rate,
       const VideoCaptureDeviceFormatsCB& callback) override;
   void StartSourceImpl(
       const media::VideoCaptureFormat& format,
@@ skipping 84 matching lines @@
   OnStartDone(MEDIA_DEVICE_OK);
 }
 
 void PpFrameWriter::StopSourceImpl() {
   DCHECK(CalledOnValidThread());
 }
 
 // Note: PutFrame must copy or process image_data directly in this function,
 // because it may be overwritten as soon as we return from this function.
 void PpFrameWriter::PutFrame(PPB_ImageData_Impl* image_data,
-                             int64 time_stamp_ns) {
+                             int64_t time_stamp_ns) {
   DCHECK(CalledOnValidThread());
   TRACE_EVENT0("video", "PpFrameWriter::PutFrame");
   DVLOG(3) << "PpFrameWriter::PutFrame()";
 
   if (!image_data) {
     LOG(ERROR) << "PpFrameWriter::PutFrame - Called with NULL image_data.";
     return;
   }
   ImageDataAutoMapper mapper(image_data);
   if (!mapper.is_valid()) {
     LOG(ERROR) << "PpFrameWriter::PutFrame - "
                << "The image could not be mapped and is unusable.";
     return;
   }
   const SkBitmap* bitmap = image_data->GetMappedBitmap();
   if (!bitmap) {
     LOG(ERROR) << "PpFrameWriter::PutFrame - "
                << "The image_data's mapped bitmap is NULL.";
     return;
   }
 
-  const uint8* src_data = static_cast<uint8*>(bitmap->getPixels());
+  const uint8_t* src_data = static_cast<uint8_t*>(bitmap->getPixels());
   const int src_stride = static_cast<int>(bitmap->rowBytes());
   const int width = bitmap->width();
   const int height = bitmap->height();
 
   // We only support PP_IMAGEDATAFORMAT_BGRA_PREMUL at the moment.
   DCHECK(image_data->format() == PP_IMAGEDATAFORMAT_BGRA_PREMUL);
 
   const gfx::Size frame_size(width, height);
 
   if (state() != MediaStreamVideoSource::STARTED)
@@ skipping 25 matching lines @@
 // is released).
 class PpFrameWriterProxy : public FrameWriterInterface {
  public:
   explicit PpFrameWriterProxy(const base::WeakPtr<PpFrameWriter>& writer)
       : writer_(writer) {
     DCHECK(writer_ != NULL);
   }
 
   ~PpFrameWriterProxy() override {}
 
-  void PutFrame(PPB_ImageData_Impl* image_data, int64 time_stamp_ns) override {
+  void PutFrame(PPB_ImageData_Impl* image_data,
+                int64_t time_stamp_ns) override {
     writer_->PutFrame(image_data, time_stamp_ns);
   }
 
  private:
   base::WeakPtr<PpFrameWriter> writer_;
 
   DISALLOW_COPY_AND_ASSIGN(PpFrameWriterProxy);
 };
 
 bool PepperToVideoTrackAdapter::Open(MediaStreamRegistryInterface* registry,
@@ skipping 38 matching lines @@
 
   stream.addTrack(MediaStreamVideoTrack::CreateVideoTrack(
       writer, constraints, MediaStreamVideoSource::ConstraintsCallback(),
       track_enabled));
 
   *frame_writer = new PpFrameWriterProxy(writer->AsWeakPtr());
   return true;
 }
 
 }  // namespace content