Fix cq compilation on win_x64

media/cast/rtcp/rtcp_sender.cc

 // Copyright 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 "media/cast/rtcp/rtcp_sender.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/trace_event.h"
@@ skipping 158 matching lines @@
 
   // SDES Source Description.
   packet->resize(start_size + 10);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
   // We always need to add one SDES CNAME.
   big_endian_writer.WriteU8(0x80 + 1);
   big_endian_writer.WriteU8(202);
 
   // Handle SDES length later on.
-  uint32 sdes_length_position = start_size + 3;
+  uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
   big_endian_writer.WriteU16(0);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(1);  // CNAME = 1
   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
 
   size_t sdes_length = 10 + c_name_.length();
   packet->insert(packet->end(), c_name_.c_str(),
                  c_name_.c_str() + c_name_.length());
 
   size_t padding = 0;
 
   // We must have a zero field even if we have an even multiple of 4 bytes.
   if ((packet->size() % 4) == 0) {
     padding++;
     packet->push_back(0);
   }
   while ((packet->size() % 4) != 0) {
     padding++;
     packet->push_back(0);
   }
   sdes_length += padding;
 
   // In 32-bit words minus one and we don't count the header.
-  uint8 buffer_length = (sdes_length / 4) - 1;
+  uint8 buffer_length = static_cast<uint8>((sdes_length / 4) - 1);
   (*packet)[sdes_length_position] = buffer_length;
 }
 
 void RtcpSender::BuildPli(uint32 remote_ssrc,
                           std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 12, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 12 > kIpPacketSize) return;
 
   packet->resize(start_size + 12);
@@ skipping 82 matching lines @@
 
   packet->resize(start_size + remb_size);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), remb_size);
 
   // Add application layer feedback.
   uint8 FMT = 15;
   big_endian_writer.WriteU8(0x80 + FMT);
   big_endian_writer.WriteU8(206);
   big_endian_writer.WriteU8(0);
-  big_endian_writer.WriteU8(remb->remb_ssrcs.size() + 4);
+  big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size() + 4));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(0);  // Remote SSRC must be 0.
   big_endian_writer.WriteU32(kRemb);
-  big_endian_writer.WriteU8(remb->remb_ssrcs.size());
+  big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size()));
 
   // 6 bit exponent and a 18 bit mantissa.
   uint8 bitrate_exponent;
   uint32 bitrate_mantissa;
   BitrateToRembExponentBitrate(remb->remb_bitrate,
                                &bitrate_exponent,
                                &bitrate_mantissa);
 
   big_endian_writer.WriteU8(static_cast<uint8>((bitrate_exponent << 2) +
       ((bitrate_mantissa >> 16) & 0x03)));
@@ skipping 15 matching lines @@
   if (start_size + 16 > kIpPacketSize) return;
 
   packet->resize(start_size + 16);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 16);
 
   uint8 FMT = 1;
   big_endian_writer.WriteU8(0x80 + FMT);
   big_endian_writer.WriteU8(205);
   big_endian_writer.WriteU8(0);
-  int nack_size_pos = start_size + 3;
+  int nack_size_pos = static_cast<int>(start_size) + 3;
   big_endian_writer.WriteU8(3);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(nack->remote_ssrc);  // Add the remote SSRC.
 
   // Build NACK bitmasks and write them to the Rtcp message.
   // The nack list should be sorted and not contain duplicates.
   int number_of_nack_fields = 0;
   int max_number_of_nack_fields =
-      std::min<int>(kRtcpMaxNackFields, (kIpPacketSize - packet->size()) / 4);
+      std::min<int>(kRtcpMaxNackFields,
+                    (kIpPacketSize - static_cast<int>(packet->size())) / 4);
 
   std::list<uint16>::const_iterator it = nack->nack_list.begin();
   while (it != nack->nack_list.end() &&
          number_of_nack_fields < max_number_of_nack_fields) {
     uint16 nack_sequence_number = *it;
     uint16 bitmask = 0;
     ++it;
     while (it != nack->nack_list.end()) {
       int shift = static_cast<uint16>(*it - nack_sequence_number) - 1;
       if (shift >= 0 && shift <= 15) {
@@ skipping 100 matching lines @@
   DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 20 > kIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
   uint8 FMT = 15;  // Application layer feedback.
   big_endian_writer.WriteU8(0x80 + FMT);
   big_endian_writer.WriteU8(206);
   big_endian_writer.WriteU8(0);
-  int cast_size_pos = start_size + 3;  // Save length position.
+  int cast_size_pos =
+      static_cast<int>(start_size) + 3; // Save length position.
   big_endian_writer.WriteU8(4);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(cast->media_ssrc_);  // Remote SSRC.
   big_endian_writer.WriteU32(kCast);
   big_endian_writer.WriteU8(cast->ack_frame_id_);
-  int cast_loss_field_pos = start_size + 17;  // Save loss field position.
+  int cast_loss_field_pos =
+      static_cast<int>(start_size) + 17;  // Save loss field position.
   big_endian_writer.WriteU8(0);  // Overwritten with number_of_loss_fields.
   big_endian_writer.WriteU8(0);  // Reserved.
   big_endian_writer.WriteU8(0);  // Reserved.
 
   int number_of_loss_fields = 0;
-  int max_number_of_loss_fields = std::min<int>(kRtcpMaxCastLossFields,
-      (kIpPacketSize - packet->size()) / 4);
+  int max_number_of_loss_fields =
+       std::min<int>(kRtcpMaxCastLossFields,
+                     kIpPacketSize - static_cast<int>(packet->size()) / 4);
 
   std::map<uint8, std::set<uint16> >::const_iterator frame_it =
       cast->missing_frames_and_packets_.begin();
 
   for (; frame_it != cast->missing_frames_and_packets_.end() &&
       number_of_loss_fields < max_number_of_loss_fields; ++frame_it) {
     // Iterate through all frames with missing packets.
     if (frame_it->second.empty()) {
       // Special case all packets in a frame is missing.
       start_size = packet->size();
@@ skipping 36 matching lines @@
   (*packet)[cast_size_pos] = static_cast<uint8>(4 + number_of_loss_fields);
   (*packet)[cast_loss_field_pos] = static_cast<uint8>(number_of_loss_fields);
 
   // Frames with missing packets.
   TRACE_COUNTER_ID1("cast_rtcp", "RtcpSender::CastNACK", ssrc_,
                     cast->missing_frames_and_packets_.size());
 }
 
 }  // namespace cast
 }  // namespace media