Fix no_size_t_to_int_warning in rtp_rtcp:rtp_rtcp_format target

webrtc/modules/rtp_rtcp/source/rtp_packet.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet.h"
 
 #include <cstring>
 #include <utility>
 
 #include "webrtc/common_types.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/random.h"
+#include "webrtc/rtc_base/safe_conversions.h"
 
 namespace webrtc {
 namespace rtp {
 namespace {
 constexpr size_t kFixedHeaderSize = 12;
 constexpr uint8_t kRtpVersion = 2;
 constexpr uint16_t kOneByteExtensionId = 0xBEDE;
 constexpr size_t kOneByteHeaderSize = 1;
 constexpr size_t kDefaultPacketSize = 1500;
 }  // namespace
 
-constexpr size_t Packet::kMaxExtensionHeaders;
+constexpr int Packet::kMaxExtensionHeaders;
 constexpr int Packet::kMinExtensionId;
 constexpr int Packet::kMaxExtensionId;
 
 //  0                   1                   2                   3
 //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 // |V=2|P|X|  CC   |M|     PT      |       sequence number         |
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 // |                           timestamp                           |
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ skipping 27 matching lines @@
     IdentifyExtensions(*extensions);
   } else {
     for (size_t i = 0; i < kMaxExtensionHeaders; ++i)
       extension_entries_[i].type = ExtensionManager::kInvalidType;
   }
 }
 
 Packet::~Packet() {}
 
 void Packet::IdentifyExtensions(const ExtensionManager& extensions) {
-  for (size_t i = 0; i < kMaxExtensionHeaders; ++i)
+  for (int i = 0; i < kMaxExtensionHeaders; ++i)
     extension_entries_[i].type = extensions.GetType(i + 1);
 }
 
 bool Packet::Parse(const uint8_t* buffer, size_t buffer_size) {
   if (!ParseBuffer(buffer, buffer_size)) {
     Clear();
     return false;
   }
   buffer_.SetData(buffer, buffer_size);
   RTC_DCHECK_EQ(size(), buffer_size);
@@ skipping 143 matching lines @@
   ByteWriter<uint32_t>::WriteBigEndian(WriteAt(8), ssrc);
 }
 
 void Packet::SetCsrcs(const std::vector<uint32_t>& csrcs) {
   RTC_DCHECK_EQ(extensions_size_, 0);
   RTC_DCHECK_EQ(payload_size_, 0);
   RTC_DCHECK_EQ(padding_size_, 0);
   RTC_DCHECK_LE(csrcs.size(), 0x0fu);
   RTC_DCHECK_LE(kFixedHeaderSize + 4 * csrcs.size(), capacity());
   payload_offset_ = kFixedHeaderSize + 4 * csrcs.size();
-  WriteAt(0, (data()[0] & 0xF0) | csrcs.size());
+  WriteAt(0, (data()[0] & 0xF0) | rtc::dchecked_cast<uint8_t>(csrcs.size()));
   size_t offset = kFixedHeaderSize;
   for (uint32_t csrc : csrcs) {
     ByteWriter<uint32_t>::WriteBigEndian(WriteAt(offset), csrc);
     offset += 4;
   }
   buffer_.SetSize(payload_offset_);
 }
 
 bool Packet::HasRawExtension(int id) const {
   if (id == ExtensionManager::kInvalidId)
@@ skipping 65 matching lines @@
 
   // All checks passed, write down the extension headers.
   if (extensions_size_ == 0) {
     RTC_DCHECK_EQ(payload_offset_, kFixedHeaderSize + (num_csrc * 4));
     WriteAt(0, data()[0] | 0x10);  // Set extension bit.
     // Profile specific ID always set to OneByteExtensionHeader.
     ByteWriter<uint16_t>::WriteBigEndian(WriteAt(extensions_offset - 4),
                                          kOneByteExtensionId);
   }
 
-  WriteAt(extensions_offset + extensions_size_, (id << 4) | (length - 1));
+  uint8_t one_byte_header = rtc::dchecked_cast<uint8_t>(id) << 4;
+  one_byte_header |= rtc::dchecked_cast<uint8_t>(length - 1);
+  WriteAt(extensions_offset + extensions_size_, one_byte_header);
 
-  extension_entry->offset =
-      extensions_offset + extensions_size_ + kOneByteHeaderSize;
-  extension_entry->length = length;
-  extensions_size_ = new_extensions_size;
+  extension_entry->offset = rtc::dchecked_cast<uint16_t>(
+      extensions_offset + extensions_size_ + kOneByteHeaderSize);
+  extension_entry->length = rtc::dchecked_cast<uint8_t>(length);
+  extensions_size_ = rtc::dchecked_cast<uint16_t>(new_extensions_size);
 
   // Update header length field.
   uint16_t extensions_words = (extensions_size_ + 3) / 4;  // Wrap up to 32bit.
   ByteWriter<uint16_t>::WriteBigEndian(WriteAt(extensions_offset - 2),
                                        extensions_words);
   // Fill extension padding place with zeroes.
   size_t extension_padding_size = 4 * extensions_words - extensions_size_;
   memset(WriteAt(extensions_offset + extensions_size_), 0,
          extension_padding_size);
   payload_offset_ = extensions_offset + 4 * extensions_words;
@@ skipping 143 matching lines @@
           break;
         }
 
         size_t idx = id - 1;
         if (extension_entries_[idx].length != 0) {
           LOG(LS_VERBOSE) << "Duplicate rtp header extension id " << id
                           << ". Overwriting.";
         }
 
         extensions_size_ += kOneByteHeaderSize;
-        extension_entries_[idx].offset = extension_offset + extensions_size_;
-        extension_entries_[idx].length = length;
+        extension_entries_[idx].offset =
+            rtc::dchecked_cast<uint16_t>(extension_offset + extensions_size_);
+        extension_entries_[idx].length = rtc::dchecked_cast<uint16_t>(length);
         extensions_size_ += length;
       }
     }
     payload_offset_ = extension_offset + extensions_capacity;
   }
 
   if (payload_offset_ + padding_size_ > size) {
     return false;
   }
   payload_size_ = size - payload_offset_ - padding_size_;
   return true;
 }
 
 rtc::ArrayView<const uint8_t> Packet::FindExtension(ExtensionType type) const {
   for (const ExtensionInfo& extension : extension_entries_) {
     if (extension.type == type) {
       if (extension.length == 0) {
         // Extension is registered but not set.
         return nullptr;
       }
       return rtc::MakeArrayView(data() + extension.offset, extension.length);
     }
   }
   return nullptr;
 }
 
 rtc::ArrayView<uint8_t> Packet::AllocateExtension(ExtensionType type,
                                                   size_t length) {
-  for (size_t i = 0; i < kMaxExtensionHeaders; ++i) {
+  for (int i = 0; i < kMaxExtensionHeaders; ++i) {
     if (extension_entries_[i].type == type) {
       int extension_id = i + 1;
       return AllocateRawExtension(extension_id, length);
     }
   }
   // Extension not registered.
   return nullptr;
 }
 
 uint8_t* Packet::WriteAt(size_t offset) {
   return buffer_.data() + offset;
 }
 
 void Packet::WriteAt(size_t offset, uint8_t byte) {
   buffer_.data()[offset] = byte;
 }
 
 }  // namespace rtp
 }  // namespace webrtc