Switch to standard integer types in chrome/browser/, part 2 of 4.

chrome/browser/media/webrtc_rtp_dump_writer.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 "chrome/browser/media/webrtc_rtp_dump_writer.h"
 
+#include <string.h>
+
 #include "base/big_endian.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/zlib/zlib.h"
 
 using content::BrowserThread;
 
 namespace {
 
 static const size_t kMinimumGzipOutputBufferSize = 256;  // In bytes.
 
 const unsigned char kRtpDumpFileHeaderFirstLine[] = "#!rtpplay1.0 0.0.0.0/0\n";
 static const size_t kRtpDumpFileHeaderSize = 16;  // In bytes.
 
 // A helper for writing the header of the dump file.
 void WriteRtpDumpFileHeaderBigEndian(base::TimeTicks start,
-                                     std::vector<uint8>* output) {
+                                     std::vector<uint8_t>* output) {
   size_t buffer_start_pos = output->size();
   output->resize(output->size() + kRtpDumpFileHeaderSize);
 
   char* buffer = reinterpret_cast<char*>(&(*output)[buffer_start_pos]);
 
   base::TimeDelta delta = start - base::TimeTicks();
-  uint32 start_sec = delta.InSeconds();
+  uint32_t start_sec = delta.InSeconds();
   base::WriteBigEndian(buffer, start_sec);
   buffer += sizeof(start_sec);
 
-  uint32 start_usec =
+  uint32_t start_usec =
       delta.InMilliseconds() * base::Time::kMicrosecondsPerMillisecond;
   base::WriteBigEndian(buffer, start_usec);
   buffer += sizeof(start_usec);
 
   // Network source, always 0.
-  base::WriteBigEndian(buffer, uint32(0));
-  buffer += sizeof(uint32);
+  base::WriteBigEndian(buffer, uint32_t(0));
+  buffer += sizeof(uint32_t);
 
   // UDP port, always 0.
-  base::WriteBigEndian(buffer, uint16(0));
-  buffer += sizeof(uint16);
+  base::WriteBigEndian(buffer, uint16_t(0));
+  buffer += sizeof(uint16_t);
 
   // 2 bytes padding.
-  base::WriteBigEndian(buffer, uint16(0));
+  base::WriteBigEndian(buffer, uint16_t(0));
 }
 
 // The header size for each packet dump.
 static const size_t kPacketDumpHeaderSize = 8;  // In bytes.
 
 // A helper for writing the header for each packet dump.
 // |start| is the time when the recording is started.
 // |dump_length| is the length of the packet dump including this header.
 // |packet_length| is the length of the RTP packet header.
 void WritePacketDumpHeaderBigEndian(const base::TimeTicks& start,
-                                    uint16 dump_length,
-                                    uint16 packet_length,
-                                    std::vector<uint8>* output) {
+                                    uint16_t dump_length,
+                                    uint16_t packet_length,
+                                    std::vector<uint8_t>* output) {
   size_t buffer_start_pos = output->size();
   output->resize(output->size() + kPacketDumpHeaderSize);
 
   char* buffer = reinterpret_cast<char*>(&(*output)[buffer_start_pos]);
 
   base::WriteBigEndian(buffer, dump_length);
   buffer += sizeof(dump_length);
 
   base::WriteBigEndian(buffer, packet_length);
   buffer += sizeof(packet_length);
 
-  uint32 elapsed =
-      static_cast<uint32>((base::TimeTicks::Now() - start).InMilliseconds());
+  uint32_t elapsed =
+      static_cast<uint32_t>((base::TimeTicks::Now() - start).InMilliseconds());
   base::WriteBigEndian(buffer, elapsed);
 }
 
 // Append |src_len| bytes from |src| to |dest|.
-void AppendToBuffer(const uint8* src,
+void AppendToBuffer(const uint8_t* src,
                     size_t src_len,
-                    std::vector<uint8>* dest) {
+                    std::vector<uint8_t>* dest) {
   size_t old_dest_size = dest->size();
   dest->resize(old_dest_size + src_len);
   memcpy(&(*dest)[old_dest_size], src, src_len);
 }
 
 }  // namespace
 
 // This class is running on the FILE thread for compressing and writing the
 // dump buffer to disk.
 class WebRtcRtpDumpWriter::FileThreadWorker {
@@ skipping 18 matching lines @@
     DCHECK(thread_checker_.CalledOnValidThread());
 
     // Makes sure all allocations are freed.
     deflateEnd(&stream_);
   }
 
   // Compresses the data in |buffer| and write to the dump file. If |end_stream|
   // is true, the compression stream will be ended and the dump file cannot be
   // written to any more.
   void CompressAndWriteToFileOnFileThread(
-      scoped_ptr<std::vector<uint8> > buffer,
+      scoped_ptr<std::vector<uint8_t>> buffer,
       bool end_stream,
       FlushResult* result,
       size_t* bytes_written) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     // This is called either when the in-memory buffer is full or the dump
     // should be ended.
     DCHECK(!buffer->empty() || end_stream);
 
     *result = FLUSH_RESULT_SUCCESS;
     *bytes_written = 0;
 
     // There may be nothing to compress/write if there is no RTP packet since
     // the last flush.
     if (!buffer->empty()) {
       *bytes_written = CompressAndWriteBufferToFile(buffer.get(), result);
     } else if (!base::PathExists(dump_path_)) {
       // If the dump does not exist, it means there is no RTP packet recorded.
       // Return FLUSH_RESULT_NO_DATA to indicate no dump file created.
       *result = FLUSH_RESULT_NO_DATA;
     }
 
     if (end_stream && !EndDumpFile())
       *result = FLUSH_RESULT_FAILURE;
   }
 
  private:
   // Helper for CompressAndWriteToFileOnFileThread to compress and write one
   // dump.
-  size_t CompressAndWriteBufferToFile(std::vector<uint8>* buffer,
+  size_t CompressAndWriteBufferToFile(std::vector<uint8_t>* buffer,
                                       FlushResult* result) {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(buffer->size());
 
     *result = FLUSH_RESULT_SUCCESS;
 
-    std::vector<uint8> compressed_buffer;
+    std::vector<uint8_t> compressed_buffer;
     if (!Compress(buffer, &compressed_buffer)) {
       DVLOG(2) << "Compressing buffer failed.";
       *result = FLUSH_RESULT_FAILURE;
       return 0;
     }
 
     int bytes_written = -1;
 
     if (base::PathExists(dump_path_)) {
       bytes_written =
@@ skipping 13 matching lines @@
       DVLOG(2) << "Writing file failed: " << dump_path_.value();
       *result = FLUSH_RESULT_FAILURE;
       return 0;
     }
 
     DCHECK_EQ(static_cast<size_t>(bytes_written), compressed_buffer.size());
     return bytes_written;
   }
 
   // Compresses |input| into |output|.
-  bool Compress(std::vector<uint8>* input, std::vector<uint8>* output) {
+  bool Compress(std::vector<uint8_t>* input, std::vector<uint8_t>* output) {
     DCHECK(thread_checker_.CalledOnValidThread());
     int result = Z_OK;
 
     output->resize(std::max(kMinimumGzipOutputBufferSize, input->size()));
 
     stream_.next_in = &(*input)[0];
     stream_.avail_in = input->size();
     stream_.next_out = &(*output)[0];
     stream_.avail_out = output->size();
 
     result = deflate(&stream_, Z_SYNC_FLUSH);
     DCHECK_EQ(Z_OK, result);
     DCHECK_EQ(0U, stream_.avail_in);
 
     output->resize(output->size() - stream_.avail_out);
 
     stream_.next_in = NULL;
     stream_.next_out = NULL;
     stream_.avail_out = 0;
     return true;
   }
 
   // Ends the compression stream and completes the dump file.
   bool EndDumpFile() {
     DCHECK(thread_checker_.CalledOnValidThread());
 
-    std::vector<uint8> output_buffer;
+    std::vector<uint8_t> output_buffer;
     output_buffer.resize(kMinimumGzipOutputBufferSize);
 
     stream_.next_in = NULL;
     stream_.avail_in = 0;
     stream_.next_out = &output_buffer[0];
     stream_.avail_out = output_buffer.size();
 
     int result = deflate(&stream_, Z_FINISH);
     DCHECK_EQ(Z_STREAM_END, result);
 
@@ skipping 37 matching lines @@
 
   bool success = BrowserThread::DeleteSoon(
       BrowserThread::FILE, FROM_HERE, incoming_file_thread_worker_.release());
   DCHECK(success);
 
   success = BrowserThread::DeleteSoon(
       BrowserThread::FILE, FROM_HERE, outgoing_file_thread_worker_.release());
   DCHECK(success);
 }
 
-void WebRtcRtpDumpWriter::WriteRtpPacket(const uint8* packet_header,
+void WebRtcRtpDumpWriter::WriteRtpPacket(const uint8_t* packet_header,
                                          size_t header_length,
                                          size_t packet_length,
                                          bool incoming) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   static const size_t kMaxInMemoryBufferSize = 65536;
 
-  std::vector<uint8>* dest_buffer =
+  std::vector<uint8_t>* dest_buffer =
       incoming ? &incoming_buffer_ : &outgoing_buffer_;
 
   // We use the capacity of the buffer to indicate if the buffer has been
   // initialized and if the dump file header has been created.
   if (!dest_buffer->capacity()) {
     dest_buffer->reserve(std::min(kMaxInMemoryBufferSize, max_dump_size_));
 
     start_time_ = base::TimeTicks::Now();
 
     // Writes the dump file header.
@@ skipping 50 matching lines @@
 }
 
 WebRtcRtpDumpWriter::EndDumpContext::~EndDumpContext() {
 }
 
 void WebRtcRtpDumpWriter::FlushBuffer(bool incoming,
                                       bool end_stream,
                                       const FlushDoneCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  scoped_ptr<std::vector<uint8> > new_buffer(new std::vector<uint8>());
+  scoped_ptr<std::vector<uint8_t>> new_buffer(new std::vector<uint8_t>());
 
   if (incoming) {
     new_buffer->reserve(incoming_buffer_.capacity());
     new_buffer->swap(incoming_buffer_);
   } else {
     new_buffer->reserve(outgoing_buffer_.capacity());
     new_buffer->swap(outgoing_buffer_);
   }
 
   scoped_ptr<FlushResult> result(new FlushResult(FLUSH_RESULT_FAILURE));
@@ skipping 70 matching lines @@
                 base::Bind(&WebRtcRtpDumpWriter::OnDumpEnded,
                            weak_ptr_factory_.GetWeakPtr(),
                            context,
                            false));
     return;
   }
 
   // This object might be deleted after running the callback.
   context.callback.Run(context.incoming_succeeded, context.outgoing_succeeded);
 }