RTC_[D]CHECK_op: Remove superfluous casts

webrtc/modules/rtp_rtcp/source/rtcp_sender.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 85 matching lines @@
     if (transport_->SendRtcp(data, length)) {
       bytes_sent_ += length;
       if (event_log_) {
         event_log_->LogRtcpPacket(kOutgoingPacket, MediaType::ANY, data,
                                   length);
       }
     }
   }
 
   size_t SendPackets(size_t max_payload_length) {
-    RTC_DCHECK_LE(max_payload_length, static_cast<size_t>(IP_PACKET_SIZE));
+    RTC_DCHECK_LE(max_payload_length, IP_PACKET_SIZE);
     uint8_t buffer[IP_PACKET_SIZE];
     BuildExternalBuffer(buffer, max_payload_length, this);
     return bytes_sent_;
   }
 
  private:
   Transport* transport_;
   RtcEventLog* const event_log_;
   size_t bytes_sent_;
 
@@ skipping 201 matching lines @@
 
 void RTCPSender::SetRemoteSSRC(uint32_t ssrc) {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   remote_ssrc_ = ssrc;
 }
 
 int32_t RTCPSender::SetCNAME(const char* c_name) {
   if (!c_name)
     return -1;
 
-  RTC_DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
+  RTC_DCHECK_LT(strlen(c_name), RTCP_CNAME_SIZE);
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   cname_ = c_name;
   return 0;
 }
 
 int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC, const char* c_name) {
   RTC_DCHECK(c_name);
-  RTC_DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
+  RTC_DCHECK_LT(strlen(c_name), RTCP_CNAME_SIZE);
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   if (csrc_cnames_.size() >= kRtpCsrcSize)
     return -1;
 
   csrc_cnames_[SSRC] = c_name;
   return 0;
 }
 
 int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
@@ skipping 112 matching lines @@
     report->AddReportBlock(it.second);
 
   report_blocks_.clear();
 
   return std::unique_ptr<rtcp::RtcpPacket>(report);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES(
     const RtcpContext& ctx) {
   size_t length_cname = cname_.length();
-  RTC_CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE));
+  RTC_CHECK_LT(length_cname, RTCP_CNAME_SIZE);
 
   rtcp::Sdes* sdes = new rtcp::Sdes();
   sdes->AddCName(ssrc_, cname_);
 
   for (const auto it : csrc_cnames_)
     sdes->AddCName(it.first, it.second);
 
   return std::unique_ptr<rtcp::RtcpPacket>(sdes);
 }
 
@@ skipping 446 matching lines @@
     uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
     receiveTime <<= 16;
     receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
 
     block->SetDelayLastSr(now - receiveTime);
   }
   return true;
 }
 
 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
-  RTC_DCHECK_LE(csrcs.size(), static_cast<size_t>(kRtpCsrcSize));
+  RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   csrcs_ = csrcs;
 }
 
 int32_t RTCPSender::SetApplicationSpecificData(uint8_t subType,
                                                uint32_t name,
                                                const uint8_t* data,
                                                uint16_t length) {
   if (length % 4 != 0) {
     LOG(LS_ERROR) << "Failed to SetApplicationSpecificData.";
@@ skipping 83 matching lines @@
     }
 
     Transport* const transport_;
     RtcEventLog* const event_log_;
     bool send_failure_;
     // TODO(terelius): We would like to
     // RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Sender);
     // but we can't because of an incorrect warning (C4822) in MVS 2013.
   } sender(transport_, event_log_);
 
-  RTC_DCHECK_LE(max_payload_length_, static_cast<size_t>(IP_PACKET_SIZE));
+  RTC_DCHECK_LE(max_payload_length_, IP_PACKET_SIZE);
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc