diff --git a/webrtc/modules/rtp_rtcp/interface/fec_receiver.h b/webrtc/modules/rtp_rtcp/interface/fec_receiver.h
index e2ef4b1..da54bf6 100644
--- a/webrtc/modules/rtp_rtcp/interface/fec_receiver.h
+++ b/webrtc/modules/rtp_rtcp/interface/fec_receiver.h
@@ -24,7 +24,7 @@
 
   virtual int32_t AddReceivedRedPacket(const RTPHeader& rtp_header,
                                        const uint8_t* incoming_rtp_packet,
-                                       int packet_length,
+                                       size_t packet_length,
                                        uint8_t ulpfec_payload_type) = 0;
 
   virtual int32_t ProcessReceivedFec() = 0;
diff --git a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
index 6f2ea4f..ae1fbb6 100644
--- a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
+++ b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
@@ -26,7 +26,7 @@
   virtual ~StreamStatistician();
 
   virtual bool GetStatistics(RtcpStatistics* statistics, bool reset) = 0;
-  virtual void GetDataCounters(uint32_t* bytes_received,
+  virtual void GetDataCounters(size_t* bytes_received,
                                uint32_t* packets_received) const = 0;
   virtual uint32_t BitrateReceived() const = 0;
 
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h b/webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h
index 327ea16..bbdac67 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h
@@ -83,7 +83,7 @@
 
   bool RestoreOriginalPacket(uint8_t** restored_packet,
                              const uint8_t* packet,
-                             int* packet_length,
+                             size_t* packet_length,
                              uint32_t original_ssrc,
                              const RTPHeader& header) const;
 
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_receiver.h b/webrtc/modules/rtp_rtcp/interface/rtp_receiver.h
index 00e5e5d..6283566 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_receiver.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_receiver.h
@@ -72,7 +72,7 @@
   // detected and acted upon.
   virtual bool IncomingRtpPacket(const RTPHeader& rtp_header,
                                  const uint8_t* payload,
-                                 int payload_length,
+                                 size_t payload_length,
                                  PayloadUnion payload_specific,
                                  bool in_order) = 0;
 
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
index ca686c0..c1250b9 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
@@ -83,7 +83,7 @@
    ***************************************************************************/
 
     virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
-                                       uint16_t incoming_packet_length) = 0;
+                                       size_t incoming_packet_length) = 0;
 
     virtual void SetRemoteSSRC(const uint32_t ssrc) = 0;
 
@@ -328,7 +328,7 @@
         const uint32_t timeStamp,
         int64_t capture_time_ms,
         const uint8_t* payloadData,
-        const uint32_t payloadSize,
+        const size_t payloadSize,
         const RTPFragmentationHeader* fragmentation = NULL,
         const RTPVideoHeader* rtpVideoHdr = NULL) = 0;
 
@@ -337,7 +337,7 @@
                                   int64_t capture_time_ms,
                                   bool retransmission) = 0;
 
-    virtual int TimeToSendPadding(int bytes) = 0;
+    virtual size_t TimeToSendPadding(size_t bytes) = 0;
 
     virtual bool GetSendSideDelay(int* avg_send_delay_ms,
                                   int* max_send_delay_ms) const = 0;
@@ -465,7 +465,7 @@
     *   return -1 on failure else 0
     */
     virtual int32_t DataCountersRTP(
-        uint32_t* bytesSent,
+        size_t* bytesSent,
         uint32_t* packetsSent) const = 0;
     /*
     *   Get received RTCP sender info
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index dc51467..e94be57 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -143,7 +143,7 @@
                                   // instead of padding.
 };
 
-const int kRtxHeaderSize = 2;
+const size_t kRtxHeaderSize = 2;
 
 struct RTCPSenderInfo
 {
@@ -220,11 +220,11 @@
 
     virtual int32_t OnReceivedPayloadData(
         const uint8_t* payloadData,
-        const uint16_t payloadSize,
+        const size_t payloadSize,
         const WebRtcRTPHeader* rtpHeader) = 0;
 
     virtual bool OnRecoveredPacket(const uint8_t* packet,
-                                   int packet_length) = 0;
+                                   size_t packet_length) = 0;
 };
 
 class RtpFeedback
@@ -334,13 +334,13 @@
 
   virtual int32_t OnReceivedPayloadData(
       const uint8_t* payloadData,
-      const uint16_t payloadSize,
+      const size_t payloadSize,
       const WebRtcRTPHeader* rtpHeader) OVERRIDE {
     return 0;
   }
 
   virtual bool OnRecoveredPacket(const uint8_t* packet,
-                                 int packet_length) OVERRIDE {
+                                 size_t packet_length) OVERRIDE {
     return true;
   }
 };
diff --git a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
index 584b9ad..7880660 100644
--- a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
@@ -23,11 +23,11 @@
  public:
   MOCK_METHOD3(OnReceivedPayloadData,
                int32_t(const uint8_t* payloadData,
-                       const uint16_t payloadSize,
+                       const size_t payloadSize,
                        const WebRtcRTPHeader* rtpHeader));
 
   MOCK_METHOD2(OnRecoveredPacket,
-               bool(const uint8_t* packet, int packet_length));
+               bool(const uint8_t* packet, size_t packet_length));
 };
 
 class MockRtpRtcp : public RtpRtcp {
@@ -47,7 +47,7 @@
   MOCK_METHOD0(DeRegisterSyncModule,
       int32_t());
   MOCK_METHOD2(IncomingRtcpPacket,
-      int32_t(const uint8_t* incomingPacket, uint16_t packetLength));
+      int32_t(const uint8_t* incomingPacket, size_t packetLength));
   MOCK_METHOD1(SetRemoteSSRC, void(const uint32_t ssrc));
   MOCK_METHOD4(IncomingAudioNTP,
       int32_t(const uint32_t audioReceivedNTPsecs,
@@ -126,14 +126,14 @@
               const uint32_t timeStamp,
               int64_t capture_time_ms,
               const uint8_t* payloadData,
-              const uint32_t payloadSize,
+              const size_t payloadSize,
               const RTPFragmentationHeader* fragmentation,
               const RTPVideoHeader* rtpVideoHdr));
   MOCK_METHOD4(TimeToSendPacket,
       bool(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms,
            bool retransmission));
   MOCK_METHOD1(TimeToSendPadding,
-      int(int bytes));
+      size_t(size_t bytes));
   MOCK_CONST_METHOD2(GetSendSideDelay,
       bool(int* avg_send_delay_ms, int* max_send_delay_ms));
   MOCK_METHOD2(RegisterRtcpObservers,
@@ -172,7 +172,7 @@
   MOCK_METHOD0(ResetSendDataCountersRTP,
       int32_t());
   MOCK_CONST_METHOD2(DataCountersRTP,
-      int32_t(uint32_t *bytesSent, uint32_t *packetsSent));
+      int32_t(size_t *bytesSent, uint32_t *packetsSent));
   MOCK_METHOD1(RemoteRTCPStat,
       int32_t(RTCPSenderInfo* senderInfo));
   MOCK_CONST_METHOD1(RemoteRTCPStat,
diff --git a/webrtc/modules/rtp_rtcp/source/bitrate.cc b/webrtc/modules/rtp_rtcp/source/bitrate.cc
index 11b3cb2..0d50221 100644
--- a/webrtc/modules/rtp_rtcp/source/bitrate.cc
+++ b/webrtc/modules/rtp_rtcp/source/bitrate.cc
@@ -32,7 +32,7 @@
 
 Bitrate::~Bitrate() {}
 
-void Bitrate::Update(const int32_t bytes) {
+void Bitrate::Update(const size_t bytes) {
   CriticalSectionScoped cs(crit_.get());
   bytes_count_ += bytes;
   packet_count_++;
diff --git a/webrtc/modules/rtp_rtcp/source/bitrate.h b/webrtc/modules/rtp_rtcp/source/bitrate.h
index 36fa1d3..086db2a 100644
--- a/webrtc/modules/rtp_rtcp/source/bitrate.h
+++ b/webrtc/modules/rtp_rtcp/source/bitrate.h
@@ -35,7 +35,7 @@
   void Process();
 
   // Update with a packet.
-  void Update(const int32_t bytes);
+  void Update(const size_t bytes);
 
   // Packet rate last second, updated roughly every 100 ms.
   uint32_t PacketRate() const;
@@ -68,7 +68,7 @@
   int64_t bitrate_array_[10];
   int64_t bitrate_diff_ms_[10];
   int64_t time_last_rate_update_;
-  uint32_t bytes_count_;
+  size_t bytes_count_;
   uint32_t packet_count_;
   Observer* const observer_;
 };
diff --git a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.cc b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.cc
index e795841..0fcb6f7 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.cc
@@ -71,10 +71,10 @@
 
 int32_t FecReceiverImpl::AddReceivedRedPacket(
     const RTPHeader& header, const uint8_t* incoming_rtp_packet,
-    int packet_length, uint8_t ulpfec_payload_type) {
+    size_t packet_length, uint8_t ulpfec_payload_type) {
   CriticalSectionScoped cs(crit_sect_.get());
   uint8_t REDHeaderLength = 1;
-  uint16_t payload_data_length = packet_length - header.headerLength;
+  size_t payload_data_length = packet_length - header.headerLength;
 
   // Add to list without RED header, aka a virtual RTP packet
   // we remove the RED header
diff --git a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h
index b876bed..8dd02b3 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h
@@ -30,7 +30,7 @@
 
   virtual int32_t AddReceivedRedPacket(const RTPHeader& rtp_header,
                                        const uint8_t* incoming_rtp_packet,
-                                       int packet_length,
+                                       size_t packet_length,
                                        uint8_t ulpfec_payload_type) OVERRIDE;
 
   virtual int32_t ProcessReceivedFec() OVERRIDE;
diff --git a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
index 0ffd5bf..a85e749 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
+++ b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
@@ -44,7 +44,7 @@
 
 // Creates a new RtpPacket with the RED header added to the packet.
 RtpPacket* FrameGenerator::BuildMediaRedPacket(const RtpPacket* packet) {
-  const int kHeaderLength = packet->header.header.headerLength;
+  const size_t kHeaderLength = packet->header.header.headerLength;
   RtpPacket* red_packet = new RtpPacket;
   red_packet->header = packet->header;
   red_packet->length = packet->length + 1;  // 1 byte RED header.
@@ -65,7 +65,7 @@
   ++num_packets_;
   RtpPacket* red_packet = NextPacket(0, packet->length + 1);
   red_packet->data[1] &= ~0x80;  // Clear marker bit.
-  const int kHeaderLength = red_packet->header.header.headerLength;
+  const size_t kHeaderLength = red_packet->header.header.headerLength;
   SetRedHeader(red_packet, kFecPayloadType, kHeaderLength);
   memcpy(red_packet->data + kHeaderLength + 1, packet->data, packet->length);
   red_packet->length = kHeaderLength + 1 + packet->length;
@@ -73,7 +73,7 @@
 }
 
 void FrameGenerator::SetRedHeader(Packet* red_packet, uint8_t payload_type,
-                                  int header_length) const {
+                                  size_t header_length) const {
   // Replace pltype.
   red_packet->data[1] &= 0x80;             // Reset.
   red_packet->data[1] += kRedPayloadType;  // Replace.
diff --git a/webrtc/modules/rtp_rtcp/source/fec_test_helper.h b/webrtc/modules/rtp_rtcp/source/fec_test_helper.h
index e6426ea..8253961 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_test_helper.h
+++ b/webrtc/modules/rtp_rtcp/source/fec_test_helper.h
@@ -51,7 +51,7 @@
   RtpPacket* BuildFecRedPacket(const Packet* packet);
 
   void SetRedHeader(Packet* red_packet, uint8_t payload_type,
-                    int header_length) const;
+                    size_t header_length) const;
 
  private:
   static void BuildRtpHeader(uint8_t* data, const RTPHeader* header);
diff --git a/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc b/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc
index b02ea08..9010e7e 100644
--- a/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc
+++ b/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc
@@ -693,7 +693,7 @@
 
   // XOR with RTP payload.
   // TODO(marpan/ajm): Are we doing more XORs than required here?
-  for (int32_t i = kRtpHeaderSize; i < src_packet->length; ++i) {
+  for (size_t i = kRtpHeaderSize; i < src_packet->length; ++i) {
     dst_packet->pkt->data[i] ^= src_packet->data[i];
   }
 }
@@ -816,7 +816,7 @@
   return 0;
 }
 
-uint16_t ForwardErrorCorrection::PacketOverhead() {
+size_t ForwardErrorCorrection::PacketOverhead() {
   return kFecHeaderSize + kUlpHeaderSizeLBitSet;
 }
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/forward_error_correction.h b/webrtc/modules/rtp_rtcp/source/forward_error_correction.h
index bb790f3..a3b3fa0 100644
--- a/webrtc/modules/rtp_rtcp/source/forward_error_correction.h
+++ b/webrtc/modules/rtp_rtcp/source/forward_error_correction.h
@@ -49,7 +49,7 @@
     // reaches zero.
     virtual int32_t Release();
 
-    uint16_t length;               // Length of packet in bytes.
+    size_t length;               // Length of packet in bytes.
     uint8_t data[IP_PACKET_SIZE];  // Packet data.
 
    private:
@@ -200,7 +200,7 @@
   // Gets the size in bytes of the FEC/ULP headers, which must be accounted for
   // as packet overhead.
   // \return Packet overhead in bytes.
-  static uint16_t PacketOverhead();
+  static size_t PacketOverhead();
 
   // Reset internal states from last frame and clear the recovered_packet_list.
   // Frees all memory allocated by this class.
diff --git a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
index b852205..d6e557d 100644
--- a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
@@ -40,7 +40,7 @@
 
   virtual int32_t OnReceivedPayloadData(
       const uint8_t* data,
-      const uint16_t size,
+      const size_t size,
       const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE {
     if (!sequence_numbers_.empty())
       EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc);
@@ -95,7 +95,7 @@
     packet_loss_ = 0;
   }
 
-  virtual int SendPacket(int channel, const void *data, int len) OVERRIDE {
+  virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE {
     count_++;
     const unsigned char* ptr = static_cast<const unsigned  char*>(data);
     uint32_t ssrc = (ptr[8] << 24) + (ptr[9] << 16) + (ptr[10] << 8) + ptr[11];
@@ -105,13 +105,13 @@
         sequence_number);
     if (packet_loss_ > 0) {
       if ((count_ % packet_loss_) == 0) {
-        return len;
+        return static_cast<int>(len);
       }
     } else if (count_ >= consecutive_drop_start_ &&
         count_ < consecutive_drop_end_) {
-      return len;
+      return static_cast<int>(len);
     }
-    int packet_length = len;
+    size_t packet_length = len;
     // TODO(pbos): Figure out why this needs to be initialized. Likely this
     // is hiding a bug either in test setup or other code.
     // https://code.google.com/p/webrtc/issues/detail?id=3183
@@ -143,12 +143,14 @@
                                           true)) {
       return -1;
     }
-    return len;
+    return static_cast<int>(len);
   }
 
-  virtual int SendRTCPPacket(int channel, const void *data, int len) OVERRIDE {
+  virtual int SendRTCPPacket(int channel,
+                             const void *data,
+                             size_t len) OVERRIDE {
     if (module_->IncomingRtcpPacket((const uint8_t*)data, len) == 0) {
-      return len;
+      return static_cast<int>(len);
     }
     return -1;
   }
@@ -214,7 +216,7 @@
                                                        0,
                                                        video_codec.maxBitrate));
 
-    for (int n = 0; n < payload_data_length; n++) {
+    for (size_t n = 0; n < payload_data_length; n++) {
       payload_data[n] = n % 10;
     }
   }
@@ -292,7 +294,7 @@
   RtxLoopBackTransport transport_;
   VerifyingRtxReceiver receiver_;
   uint8_t  payload_data[65000];
-  int payload_data_length;
+  size_t payload_data_length;
   SimulatedClock fake_clock;
 };
 
diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec.cc b/webrtc/modules/rtp_rtcp/source/producer_fec.cc
index 747cd89..a571a01 100644
--- a/webrtc/modules/rtp_rtcp/source/producer_fec.cc
+++ b/webrtc/modules/rtp_rtcp/source/producer_fec.cc
@@ -36,7 +36,7 @@
   ForwardErrorCorrection::Packet* pkt;
 };
 
-RedPacket::RedPacket(int length)
+RedPacket::RedPacket(size_t length)
     : data_(new uint8_t[length]),
       length_(length),
       header_length_(0) {
@@ -46,7 +46,7 @@
   delete [] data_;
 }
 
-void RedPacket::CreateHeader(const uint8_t* rtp_header, int header_length,
+void RedPacket::CreateHeader(const uint8_t* rtp_header, size_t header_length,
                              int red_pl_type, int pl_type) {
   assert(header_length + kREDForFECHeaderLength <= length_);
   memcpy(data_, rtp_header, header_length);
@@ -64,7 +64,7 @@
   RtpUtility::AssignUWord16ToBuffer(&data_[2], seq_num);
 }
 
-void RedPacket::AssignPayload(const uint8_t* payload, int length) {
+void RedPacket::AssignPayload(const uint8_t* payload, size_t length) {
   assert(header_length_ + length <= length_);
   memcpy(data_ + header_length_, payload, length);
 }
@@ -77,7 +77,7 @@
   return data_;
 }
 
-int RedPacket::length() const {
+size_t RedPacket::length() const {
   return length_;
 }
 
@@ -120,8 +120,8 @@
 }
 
 RedPacket* ProducerFec::BuildRedPacket(const uint8_t* data_buffer,
-                                       int payload_length,
-                                       int rtp_header_length,
+                                       size_t payload_length,
+                                       size_t rtp_header_length,
                                        int red_pl_type) {
   RedPacket* red_packet = new RedPacket(payload_length +
                                         kREDForFECHeaderLength +
@@ -134,8 +134,8 @@
 }
 
 int ProducerFec::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
-                                            int payload_length,
-                                            int rtp_header_length) {
+                                            size_t payload_length,
+                                            size_t rtp_header_length) {
   assert(fec_packets_.empty());
   if (media_packets_fec_.empty()) {
     params_ = new_params_;
@@ -210,7 +210,7 @@
 RedPacket* ProducerFec::GetFecPacket(int red_pl_type,
                                      int fec_pl_type,
                                      uint16_t seq_num,
-                                     int rtp_header_length) {
+                                     size_t rtp_header_length) {
   if (fec_packets_.empty())
     return NULL;
   // Build FEC packet. The FEC packets in |fec_packets_| doesn't
diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec.h b/webrtc/modules/rtp_rtcp/source/producer_fec.h
index e3f9d1d..ec58bcf 100644
--- a/webrtc/modules/rtp_rtcp/source/producer_fec.h
+++ b/webrtc/modules/rtp_rtcp/source/producer_fec.h
@@ -21,20 +21,20 @@
 
 class RedPacket {
  public:
-  explicit RedPacket(int length);
+  explicit RedPacket(size_t length);
   ~RedPacket();
-  void CreateHeader(const uint8_t* rtp_header, int header_length,
+  void CreateHeader(const uint8_t* rtp_header, size_t header_length,
                     int red_pl_type, int pl_type);
   void SetSeqNum(int seq_num);
-  void AssignPayload(const uint8_t* payload, int length);
+  void AssignPayload(const uint8_t* payload, size_t length);
   void ClearMarkerBit();
   uint8_t* data() const;
-  int length() const;
+  size_t length() const;
 
  private:
   uint8_t* data_;
-  int length_;
-  int header_length_;
+  size_t length_;
+  size_t header_length_;
 };
 
 class ProducerFec {
@@ -46,13 +46,13 @@
                         int max_fec_frames);
 
   RedPacket* BuildRedPacket(const uint8_t* data_buffer,
-                            int payload_length,
-                            int rtp_header_length,
+                            size_t payload_length,
+                            size_t rtp_header_length,
                             int red_pl_type);
 
   int AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
-                                 int payload_length,
-                                 int rtp_header_length);
+                                 size_t payload_length,
+                                 size_t rtp_header_length);
 
   bool ExcessOverheadBelowMax();
 
@@ -63,7 +63,7 @@
   RedPacket* GetFecPacket(int red_pl_type,
                           int fec_pl_type,
                           uint16_t seq_num,
-                          int rtp_header_length);
+                          size_t rtp_header_length);
 
  private:
   void DeletePackets();
diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
index baa3827..d8b67a7 100644
--- a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
@@ -23,7 +23,7 @@
                   int fec_pltype,
                   RedPacket* packet,
                   bool marker_bit) {
-  EXPECT_GT(packet->length(), static_cast<int>(kRtpHeaderSize));
+  EXPECT_GT(packet->length(), kRtpHeaderSize);
   EXPECT_TRUE(packet->data() != NULL);
   uint8_t* data = packet->data();
   // Marker bit not set.
diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.cc b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.cc
index f063ce3..eeb6e31 100644
--- a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.cc
@@ -123,7 +123,7 @@
     last_receive_time_ms_ = clock_->TimeInMilliseconds();
   }
 
-  uint16_t packet_oh = header.headerLength + header.paddingLength;
+  size_t packet_oh = header.headerLength + header.paddingLength;
 
   // Our measured overhead. Filter from RFC 5104 4.2.1.2:
   // avg_OH (new) = 15/16*avg_OH (old) + 1/16*pckt_OH,
@@ -303,7 +303,7 @@
 }
 
 void StreamStatisticianImpl::GetDataCounters(
-    uint32_t* bytes_received, uint32_t* packets_received) const {
+    size_t* bytes_received, uint32_t* packets_received) const {
   CriticalSectionScoped cs(stream_lock_.get());
   if (bytes_received) {
     *bytes_received = receive_counters_.bytes + receive_counters_.header_bytes +
diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h
index 40ca285..bef856f 100644
--- a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h
@@ -31,7 +31,7 @@
   virtual ~StreamStatisticianImpl() {}
 
   virtual bool GetStatistics(RtcpStatistics* statistics, bool reset) OVERRIDE;
-  virtual void GetDataCounters(uint32_t* bytes_received,
+  virtual void GetDataCounters(size_t* bytes_received,
                                uint32_t* packets_received) const OVERRIDE;
   virtual uint32_t BitrateReceived() const OVERRIDE;
   virtual void ResetStatistics() OVERRIDE;
@@ -80,7 +80,7 @@
   uint16_t received_seq_wraps_;
 
   // Current counter values.
-  uint16_t received_packet_overhead_;
+  size_t received_packet_overhead_;
   StreamDataCounters receive_counters_;
 
   // Counter values when we sent the last report.
diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc b/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc
index 5b4d0dd..808a880 100644
--- a/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc
@@ -16,8 +16,8 @@
 
 namespace webrtc {
 
-const int kPacketSize1 = 100;
-const int kPacketSize2 = 300;
+const size_t kPacketSize1 = 100;
+const size_t kPacketSize2 = 300;
 const uint32_t kSsrc1 = 1;
 const uint32_t kSsrc2 = 2;
 
@@ -56,7 +56,7 @@
       receive_statistics_->GetStatistician(kSsrc1);
   ASSERT_TRUE(statistician != NULL);
   EXPECT_GT(statistician->BitrateReceived(), 0u);
-  uint32_t bytes_received = 0;
+  size_t bytes_received = 0;
   uint32_t packets_received = 0;
   statistician->GetDataCounters(&bytes_received, &packets_received);
   EXPECT_EQ(200u, bytes_received);
@@ -125,7 +125,7 @@
   StreamStatistician* statistician =
       receive_statistics_->GetStatistician(kSsrc1);
   ASSERT_TRUE(statistician != NULL);
-  uint32_t bytes_received = 0;
+  size_t bytes_received = 0;
   uint32_t packets_received = 0;
   statistician->GetDataCounters(&bytes_received, &packets_received);
   EXPECT_EQ(200u, bytes_received);
@@ -234,8 +234,8 @@
 
   void ExpectMatches(uint32_t num_calls,
                      uint32_t ssrc,
-                     uint32_t bytes,
-                     uint32_t padding,
+                     size_t bytes,
+                     size_t padding,
                      uint32_t packets,
                      uint32_t retransmits,
                      uint32_t fec) {
@@ -257,8 +257,8 @@
   RtpTestCallback callback;
   receive_statistics_->RegisterRtpStatisticsCallback(&callback);
 
-  const uint32_t kHeaderLength = 20;
-  const uint32_t kPaddingLength = 9;
+  const size_t kHeaderLength = 20;
+  const size_t kPaddingLength = 9;
 
   // One packet of size kPacketSize1.
   header1_.headerLength = kHeaderLength;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
index 17671b7..6a7b7f9 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
@@ -32,14 +32,14 @@
 
   virtual int SendPacket(int /*channel*/,
                          const void* /*data*/,
-                         int /*len*/) OVERRIDE {
+                         size_t /*len*/) OVERRIDE {
     return -1;
   }
   virtual int SendRTCPPacket(int /*channel*/,
                              const void *packet,
-                             int packetLength) OVERRIDE {
+                             size_t packetLength) OVERRIDE {
     RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet,
-                                         (int32_t)packetLength,
+                                         packetLength,
                                          true); // Allow non-compound RTCP
 
     EXPECT_TRUE(rtcpParser.IsValid());
@@ -51,7 +51,7 @@
               rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRemb);
     EXPECT_EQ((uint32_t)1234,
               rtcpPacketInformation.receiverEstimatedMaxBitrate);
-    return packetLength;
+    return static_cast<int>(packetLength);
   }
  private:
   RTCPReceiver* rtcp_receiver_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index 2a61573..d65157d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -41,7 +41,7 @@
   }
   virtual int SendPacket(int /*ch*/,
                          const void* /*data*/,
-                         int /*len*/) OVERRIDE {
+                         size_t /*len*/) OVERRIDE {
     ADD_FAILURE();  // FAIL() gives a compile error.
     return -1;
   }
@@ -49,13 +49,13 @@
   // Injects an RTCP packet into the receiver.
   virtual int SendRTCPPacket(int /* ch */,
                              const void *packet,
-                             int packet_len) OVERRIDE {
+                             size_t packet_len) OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
 
   virtual int OnReceivedPayloadData(const uint8_t* payloadData,
-                                    const uint16_t payloadSize,
+                                    const size_t payloadSize,
                                     const WebRtcRTPHeader* rtpHeader) OVERRIDE {
     ADD_FAILURE();
     return 0;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
index 1752ab9..9991992 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -1633,7 +1633,7 @@
   {
       return -1;
   }
-  return SendToNetwork(rtcp_buffer, static_cast<uint16_t>(rtcp_length));
+  return SendToNetwork(rtcp_buffer, static_cast<size_t>(rtcp_length));
 }
 
 int RTCPSender::PrepareRTCP(const FeedbackState& feedback_state,
@@ -2000,7 +2000,7 @@
 
 int32_t
 RTCPSender::SendToNetwork(const uint8_t* dataBuffer,
-                          const uint16_t length)
+                          const size_t length)
 {
     CriticalSectionScoped lock(_criticalSectionTransport);
     if(_cbTransport)
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
index 668c7c7..23f720fc 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
@@ -56,7 +56,7 @@
    uint8_t send_payload_type;
    uint32_t frequency_hz;
    uint32_t packets_sent;
-   uint32_t media_bytes_sent;
+   size_t media_bytes_sent;
    uint32_t send_bitrate;
 
    uint32_t last_rr_ntp_secs;
@@ -177,7 +177,7 @@
     void GetPacketTypeCounter(RtcpPacketTypeCounter* packet_counter) const;
 
 private:
-    int32_t SendToNetwork(const uint8_t* dataBuffer, const uint16_t length);
+    int32_t SendToNetwork(const uint8_t* dataBuffer, const size_t length);
 
     int32_t WriteAllReportBlocksToBuffer(uint8_t* rtcpbuffer,
                             int pos,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 44d4a2b..a72fe58 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -188,7 +188,7 @@
 void CreateRtpPacket(const bool marker_bit, const uint8_t payload,
     const uint16_t seq_num, const uint32_t timestamp,
     const uint32_t ssrc, uint8_t* array,
-    uint16_t* cur_pos) {
+    size_t* cur_pos) {
   ASSERT_TRUE(payload <= 127);
   array[(*cur_pos)++] = 0x80;
   array[(*cur_pos)++] = payload | (marker_bit ? 0x80 : 0);
@@ -229,15 +229,15 @@
   }
   virtual int SendPacket(int /*ch*/,
                          const void* /*data*/,
-                         int /*len*/) OVERRIDE {
+                         size_t /*len*/) OVERRIDE {
     return -1;
   }
 
   virtual int SendRTCPPacket(int /*ch*/,
                              const void *packet,
-                             int packet_len) OVERRIDE {
+                             size_t packet_len) OVERRIDE {
     RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet,
-                                         (int32_t)packet_len,
+                                         packet_len,
                                          true); // Allow non-compound RTCP
 
     EXPECT_TRUE(rtcpParser.IsValid());
@@ -262,11 +262,11 @@
     rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac;
     rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp;
 
-    return packet_len;
+    return static_cast<int>(packet_len);
   }
 
   virtual int OnReceivedPayloadData(const uint8_t* payloadData,
-                                    const uint16_t payloadSize,
+                                    const size_t payloadSize,
                                     const WebRtcRTPHeader* rtpHeader) OVERRIDE {
     return 0;
   }
@@ -357,10 +357,10 @@
   const uint16_t seq_num = 11111;
   const uint32_t timestamp = 1234567;
   const uint32_t ssrc = 0x11111111;
-  uint16_t packet_length = 0;
+  size_t packet_length = 0;
   CreateRtpPacket(marker_bit, payload, seq_num, timestamp, ssrc, packet_,
       &packet_length);
-  EXPECT_EQ(25, packet_length);
+  EXPECT_EQ(25u, packet_length);
 
   VideoCodec codec_inst;
   strncpy(codec_inst.plName, "VP8", webrtc::kPayloadNameSize - 1);
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc
index 9d19fde..5a3eb39 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc
@@ -896,7 +896,7 @@
   for (int i = 0; i < num_media_packets; ++i) {
     media_packet = new ForwardErrorCorrection::Packet;
     media_packet_list_.push_back(media_packet);
-    media_packet->length = static_cast<uint16_t>(
+    media_packet->length = static_cast<size_t>(
         (static_cast<float>(rand()) / RAND_MAX) *
         (IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead -
          ForwardErrorCorrection::PacketOverhead()));
@@ -928,7 +928,7 @@
     webrtc::RtpUtility::AssignUWord32ToBuffer(&media_packet->data[8], ssrc_);
 
     // Generate random values for payload.
-    for (int j = 12; j < media_packet->length; ++j) {
+    for (size_t j = 12; j < media_packet->length; ++j) {
       media_packet->data[j] = static_cast<uint8_t>(rand() % 256);
     }
     sequence_number++;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.cc
index ab210ec..1fa288a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.cc
@@ -36,7 +36,7 @@
   payload_size_ = payload_size;
 
   // Fragment packets more evenly by splitting the payload up evenly.
-  uint32_t num_packets =
+  size_t num_packets =
       (payload_size_ + max_payload_len_ - 1) / max_payload_len_;
   payload_length_ = (payload_size_ + num_packets - 1) / num_packets;
   assert(payload_length_ <= max_payload_len_);
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h
index 491cab5..2fd6aad 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h
@@ -57,7 +57,7 @@
   size_t payload_size_;
   const size_t max_payload_len_;
   FrameType frame_type_;
-  uint32_t payload_length_;
+  size_t payload_length_;
   uint8_t generic_header_;
 
   DISALLOW_COPY_AND_ASSIGN(RtpPacketizerGeneric);
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc
index d74e04f..57ff74f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.cc
@@ -22,17 +22,17 @@
 namespace {
 int ParseVP8PictureID(RTPVideoHeaderVP8* vp8,
                       const uint8_t** data,
-                      int* data_length,
-                      int* parsed_bytes) {
+                      size_t* data_length,
+                      size_t* parsed_bytes) {
   assert(vp8 != NULL);
-  if (*data_length <= 0)
+  if (*data_length == 0)
     return -1;
 
   vp8->pictureId = (**data & 0x7F);
   if (**data & 0x80) {
     (*data)++;
     (*parsed_bytes)++;
-    if (--(*data_length) <= 0)
+    if (--(*data_length) == 0)
       return -1;
     // PictureId is 15 bits
     vp8->pictureId = (vp8->pictureId << 8) + **data;
@@ -45,10 +45,10 @@
 
 int ParseVP8Tl0PicIdx(RTPVideoHeaderVP8* vp8,
                       const uint8_t** data,
-                      int* data_length,
-                      int* parsed_bytes) {
+                      size_t* data_length,
+                      size_t* parsed_bytes) {
   assert(vp8 != NULL);
-  if (*data_length <= 0)
+  if (*data_length == 0)
     return -1;
 
   vp8->tl0PicIdx = **data;
@@ -60,12 +60,12 @@
 
 int ParseVP8TIDAndKeyIdx(RTPVideoHeaderVP8* vp8,
                          const uint8_t** data,
-                         int* data_length,
-                         int* parsed_bytes,
+                         size_t* data_length,
+                         size_t* parsed_bytes,
                          bool has_tid,
                          bool has_key_idx) {
   assert(vp8 != NULL);
-  if (*data_length <= 0)
+  if (*data_length == 0)
     return -1;
 
   if (has_tid) {
@@ -83,11 +83,10 @@
 
 int ParseVP8Extension(RTPVideoHeaderVP8* vp8,
                       const uint8_t* data,
-                      int data_length) {
+                      size_t data_length) {
   assert(vp8 != NULL);
-  int parsed_bytes = 0;
-  if (data_length <= 0)
-    return -1;
+  assert(data_length > 0);
+  size_t parsed_bytes = 0;
   // Optional X field is present.
   bool has_picture_id = (*data & 0x80) ? true : false;   // I bit
   bool has_tl0_pic_idx = (*data & 0x40) ? true : false;  // L bit
@@ -118,12 +117,12 @@
       return -1;
     }
   }
-  return parsed_bytes;
+  return static_cast<int>(parsed_bytes);
 }
 
 int ParseVP8FrameSize(RtpDepacketizer::ParsedPayload* parsed_payload,
                       const uint8_t* data,
-                      int data_length) {
+                      size_t data_length) {
   assert(parsed_payload != NULL);
   if (parsed_payload->frame_type != kVideoFrameKey) {
     // Included in payload header for I-frames.
@@ -149,7 +148,7 @@
                                                                  false};
 
 RtpPacketizerVp8::RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info,
-                                   int max_payload_len,
+                                   size_t max_payload_len,
                                    VP8PacketizerMode mode)
     : payload_data_(NULL),
       payload_size_(0),
@@ -164,7 +163,7 @@
 }
 
 RtpPacketizerVp8::RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info,
-                                   int max_payload_len)
+                                   size_t max_payload_len)
     : payload_data_(NULL),
       payload_size_(0),
       part_info_(),
@@ -222,7 +221,7 @@
   if (bytes < 0) {
     return false;
   }
-  *bytes_to_send = bytes;
+  *bytes_to_send = static_cast<size_t>(bytes);
 
   *last_packet = packets_.empty();
   return true;
@@ -251,9 +250,9 @@
   return "RtpPacketizerVp8";
 }
 
-int RtpPacketizerVp8::CalcNextSize(int max_payload_len,
-                                   int remaining_bytes,
-                                   bool split_payload) const {
+size_t RtpPacketizerVp8::CalcNextSize(size_t max_payload_len,
+                                      size_t remaining_bytes,
+                                      bool split_payload) const {
   if (max_payload_len == 0 || remaining_bytes == 0) {
     return 0;
   }
@@ -265,10 +264,10 @@
     // Balance payload sizes to produce (almost) equal size
     // fragments.
     // Number of fragments for remaining_bytes:
-    int num_frags = remaining_bytes / max_payload_len + 1;
+    size_t num_frags = remaining_bytes / max_payload_len + 1;
     // Number of bytes in this fragment:
-    return static_cast<int>(static_cast<double>(remaining_bytes) / num_frags +
-                            0.5);
+    return static_cast<size_t>(
+        static_cast<double>(remaining_bytes) / num_frags + 0.5);
   } else {
     return max_payload_len >= remaining_bytes ? remaining_bytes
                                               : max_payload_len;
@@ -282,22 +281,22 @@
     // descriptor and one payload byte. Return an error.
     return -1;
   }
-  int total_bytes_processed = 0;
+  size_t total_bytes_processed = 0;
   bool start_on_new_fragment = true;
   bool beginning = true;
-  int part_ix = 0;
+  size_t part_ix = 0;
   while (total_bytes_processed < payload_size_) {
-    int packet_bytes = 0;       // How much data to send in this packet.
+    size_t packet_bytes = 0;    // How much data to send in this packet.
     bool split_payload = true;  // Splitting of partitions is initially allowed.
-    int remaining_in_partition = part_info_.fragmentationOffset[part_ix] -
+    size_t remaining_in_partition = part_info_.fragmentationOffset[part_ix] -
                                  total_bytes_processed +
                                  part_info_.fragmentationLength[part_ix];
-    int rem_payload_len =
+    size_t rem_payload_len =
         max_payload_len_ -
         (vp8_fixed_payload_descriptor_bytes_ + PayloadDescriptorExtraLength());
-    int first_partition_in_packet = part_ix;
+    size_t first_partition_in_packet = part_ix;
 
-    while (int next_size = CalcNextSize(
+    while (size_t next_size = CalcNextSize(
                rem_payload_len, remaining_in_partition, split_payload)) {
       packet_bytes += next_size;
       rem_payload_len -= next_size;
@@ -348,44 +347,44 @@
     return -1;
   }
   std::vector<int> partition_decision;
-  const int overhead =
+  const size_t overhead =
       vp8_fixed_payload_descriptor_bytes_ + PayloadDescriptorExtraLength();
-  const uint32_t max_payload_len = max_payload_len_ - overhead;
+  const size_t max_payload_len = max_payload_len_ - overhead;
   int min_size, max_size;
   AggregateSmallPartitions(&partition_decision, &min_size, &max_size);
 
-  int total_bytes_processed = 0;
-  int part_ix = 0;
+  size_t total_bytes_processed = 0;
+  size_t part_ix = 0;
   while (part_ix < num_partitions_) {
     if (partition_decision[part_ix] == -1) {
       // Split large partitions.
-      int remaining_partition = part_info_.fragmentationLength[part_ix];
-      int num_fragments = Vp8PartitionAggregator::CalcNumberOfFragments(
+      size_t remaining_partition = part_info_.fragmentationLength[part_ix];
+      size_t num_fragments = Vp8PartitionAggregator::CalcNumberOfFragments(
           remaining_partition, max_payload_len, overhead, min_size, max_size);
-      const int packet_bytes =
+      const size_t packet_bytes =
           (remaining_partition + num_fragments - 1) / num_fragments;
-      for (int n = 0; n < num_fragments; ++n) {
-        const int this_packet_bytes = packet_bytes < remaining_partition
-                                          ? packet_bytes
-                                          : remaining_partition;
+      for (size_t n = 0; n < num_fragments; ++n) {
+        const size_t this_packet_bytes = packet_bytes < remaining_partition
+                                             ? packet_bytes
+                                             : remaining_partition;
         QueuePacket(
             total_bytes_processed, this_packet_bytes, part_ix, (n == 0));
         remaining_partition -= this_packet_bytes;
         total_bytes_processed += this_packet_bytes;
-        if (this_packet_bytes < min_size) {
+        if (static_cast<int>(this_packet_bytes) < min_size) {
           min_size = this_packet_bytes;
         }
-        if (this_packet_bytes > max_size) {
+        if (static_cast<int>(this_packet_bytes) > max_size) {
           max_size = this_packet_bytes;
         }
       }
       assert(remaining_partition == 0);
       ++part_ix;
     } else {
-      int this_packet_bytes = 0;
-      const int first_partition_in_packet = part_ix;
+      size_t this_packet_bytes = 0;
+      const size_t first_partition_in_packet = part_ix;
       const int aggregation_index = partition_decision[part_ix];
-      while (static_cast<size_t>(part_ix) < partition_decision.size() &&
+      while (part_ix < partition_decision.size() &&
              partition_decision[part_ix] == aggregation_index) {
         // Collect all partitions that were aggregated into the same packet.
         this_packet_bytes += part_info_.fragmentationLength[part_ix];
@@ -410,11 +409,11 @@
   *max_size = -1;
   assert(partition_vec);
   partition_vec->assign(num_partitions_, -1);
-  const int overhead =
+  const size_t overhead =
       vp8_fixed_payload_descriptor_bytes_ + PayloadDescriptorExtraLength();
-  const uint32_t max_payload_len = max_payload_len_ - overhead;
-  int first_in_set = 0;
-  int last_in_set = 0;
+  const size_t max_payload_len = max_payload_len_ - overhead;
+  size_t first_in_set = 0;
+  size_t last_in_set = 0;
   int num_aggregate_packets = 0;
   // Find sets of partitions smaller than max_payload_len_.
   while (first_in_set < num_partitions_) {
@@ -434,7 +433,7 @@
       Vp8PartitionAggregator::ConfigVec optimal_config =
           aggregator.FindOptimalConfiguration(max_payload_len, overhead);
       aggregator.CalcMinMax(optimal_config, min_size, max_size);
-      for (int i = first_in_set, j = 0; i <= last_in_set; ++i, ++j) {
+      for (size_t i = first_in_set, j = 0; i <= last_in_set; ++i, ++j) {
         // Transfer configuration for this set of partitions to the joint
         // partition vector representing all partitions in the frame.
         (*partition_vec)[i] = num_aggregate_packets + optimal_config[j];
@@ -446,9 +445,9 @@
   }
 }
 
-void RtpPacketizerVp8::QueuePacket(int start_pos,
-                                   int packet_size,
-                                   int first_partition_in_packet,
+void RtpPacketizerVp8::QueuePacket(size_t start_pos,
+                                   size_t packet_size,
+                                   size_t first_partition_in_packet,
                                    bool start_on_new_fragment) {
   // Write info to packet info struct and store in packet info queue.
   InfoStruct packet_info;
@@ -461,7 +460,7 @@
 
 int RtpPacketizerVp8::WriteHeaderAndPayload(const InfoStruct& packet_info,
                                             uint8_t* buffer,
-                                            int buffer_length) const {
+                                            size_t buffer_length) const {
   // Write the VP8 payload descriptor.
   //       0
   //       0 1 2 3 4 5 6 7 8
@@ -488,6 +487,8 @@
   buffer[0] |= (packet_info.first_partition_ix & kPartIdField);
 
   const int extension_length = WriteExtensionFields(buffer, buffer_length);
+  if (extension_length < 0)
+    return -1;
 
   memcpy(&buffer[vp8_fixed_payload_descriptor_bytes_ + extension_length],
          &payload_data_[packet_info.payload_start_pos],
@@ -499,8 +500,8 @@
 }
 
 int RtpPacketizerVp8::WriteExtensionFields(uint8_t* buffer,
-                                           int buffer_length) const {
-  int extension_length = 0;
+                                           size_t buffer_length) const {
+  size_t extension_length = 0;
   if (XFieldPresent()) {
     uint8_t* x_field = buffer + vp8_fixed_payload_descriptor_bytes_;
     *x_field = 0;
@@ -525,14 +526,16 @@
     }
     assert(extension_length == PayloadDescriptorExtraLength());
   }
-  return extension_length;
+  return static_cast<int>(extension_length);
 }
 
 int RtpPacketizerVp8::WritePictureIDFields(uint8_t* x_field,
                                            uint8_t* buffer,
-                                           int buffer_length,
-                                           int* extension_length) const {
+                                           size_t buffer_length,
+                                           size_t* extension_length) const {
   *x_field |= kIBit;
+  assert(buffer_length >=
+      vp8_fixed_payload_descriptor_bytes_ + *extension_length);
   const int pic_id_length = WritePictureID(
       buffer + vp8_fixed_payload_descriptor_bytes_ + *extension_length,
       buffer_length - vp8_fixed_payload_descriptor_bytes_ - *extension_length);
@@ -542,9 +545,10 @@
   return 0;
 }
 
-int RtpPacketizerVp8::WritePictureID(uint8_t* buffer, int buffer_length) const {
+int RtpPacketizerVp8::WritePictureID(uint8_t* buffer,
+                                     size_t buffer_length) const {
   const uint16_t pic_id = static_cast<uint16_t>(hdr_info_.pictureId);
-  int picture_id_len = PictureIdLength();
+  size_t picture_id_len = PictureIdLength();
   if (picture_id_len > buffer_length)
     return -1;
   if (picture_id_len == 2) {
@@ -553,13 +557,13 @@
   } else if (picture_id_len == 1) {
     buffer[0] = pic_id & 0x7F;
   }
-  return picture_id_len;
+  return static_cast<int>(picture_id_len);
 }
 
 int RtpPacketizerVp8::WriteTl0PicIdxFields(uint8_t* x_field,
                                            uint8_t* buffer,
-                                           int buffer_length,
-                                           int* extension_length) const {
+                                           size_t buffer_length,
+                                           size_t* extension_length) const {
   if (buffer_length <
       vp8_fixed_payload_descriptor_bytes_ + *extension_length + 1) {
     return -1;
@@ -573,8 +577,8 @@
 
 int RtpPacketizerVp8::WriteTIDAndKeyIdxFields(uint8_t* x_field,
                                               uint8_t* buffer,
-                                              int buffer_length,
-                                              int* extension_length) const {
+                                              size_t buffer_length,
+                                              size_t* extension_length) const {
   if (buffer_length <
       vp8_fixed_payload_descriptor_bytes_ + *extension_length + 1) {
     return -1;
@@ -596,8 +600,8 @@
   return 0;
 }
 
-int RtpPacketizerVp8::PayloadDescriptorExtraLength() const {
-  int length_bytes = PictureIdLength();
+size_t RtpPacketizerVp8::PayloadDescriptorExtraLength() const {
+  size_t length_bytes = PictureIdLength();
   if (TL0PicIdxFieldPresent())
     ++length_bytes;
   if (TIDFieldPresent() || KeyIdxFieldPresent())
@@ -607,7 +611,7 @@
   return length_bytes;
 }
 
-int RtpPacketizerVp8::PictureIdLength() const {
+size_t RtpPacketizerVp8::PictureIdLength() const {
   if (hdr_info_.pictureId == kNoPictureId) {
     return 0;
   }
@@ -693,6 +697,10 @@
 
   // Advance payload_data and decrease remaining payload size.
   payload_data++;
+  if (payload_data_length <= 1) {
+    LOG(LS_ERROR) << "Error parsing VP8 payload descriptor!";
+    return false;
+  }
   payload_data_length--;
 
   if (extension) {
@@ -704,15 +712,14 @@
       return false;
     payload_data += parsed_bytes;
     payload_data_length -= parsed_bytes;
-  }
-
-  if (payload_data_length <= 0) {
-    LOG(LS_ERROR) << "Error parsing VP8 payload descriptor!";
-    return false;
+    if (payload_data_length == 0) {
+      LOG(LS_ERROR) << "Error parsing VP8 payload descriptor!";
+      return false;
+    }
   }
 
   // Read P bit from payload header (only at beginning of first partition).
-  if (payload_data_length > 0 && beginning_of_partition && partition_id == 0) {
+  if (beginning_of_partition && partition_id == 0) {
     parsed_payload->frame_type =
         (*payload_data & 0x01) ? kVideoFrameDelta : kVideoFrameKey;
   } else {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
index 4b7a6a2..dab7921 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
@@ -51,12 +51,12 @@
   // Initialize with payload from encoder and fragmentation info.
   // The payload_data must be exactly one encoded VP8 frame.
   RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info,
-                   int max_payload_len,
+                   size_t max_payload_len,
                    VP8PacketizerMode mode);
 
   // Initialize without fragmentation info. Mode kEqualSize will be used.
   // The payload_data must be exactly one encoded VP8 frame.
-  RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info, int max_payload_len);
+  RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info, size_t max_payload_len);
 
   virtual ~RtpPacketizerVp8();
 
@@ -88,10 +88,10 @@
 
  private:
   typedef struct {
-    int payload_start_pos;
-    int size;
+    size_t payload_start_pos;
+    size_t size;
     bool first_fragment;
-    int first_partition_ix;
+    size_t first_partition_ix;
   } InfoStruct;
   typedef std::queue<InfoStruct> InfoQueue;
   enum AggregationMode {
@@ -115,9 +115,9 @@
   static const int kYBit = 0x20;
 
   // Calculate size of next chunk to send. Returns 0 if none can be sent.
-  int CalcNextSize(int max_payload_len,
-                   int remaining_bytes,
-                   bool split_payload) const;
+  size_t CalcNextSize(size_t max_payload_len,
+                      size_t remaining_bytes,
+                      bool split_payload) const;
 
   // Calculate all packet sizes and load to packet info queue.
   int GeneratePackets();
@@ -140,9 +140,9 @@
                                 int* max_size);
 
   // Insert packet into packet queue.
-  void QueuePacket(int start_pos,
-                   int packet_size,
-                   int first_partition_in_packet,
+  void QueuePacket(size_t start_pos,
+                   size_t packet_size,
+                   size_t first_partition_in_packet,
                    bool start_on_new_fragment);
 
   // Write the payload header and copy the payload to the buffer.
@@ -150,47 +150,47 @@
   // and what to write in the header fields.
   int WriteHeaderAndPayload(const InfoStruct& packet_info,
                             uint8_t* buffer,
-                            int buffer_length) const;
+                            size_t buffer_length) const;
 
   // Write the X field and the appropriate extension fields to buffer.
   // The function returns the extension length (including X field), or -1
   // on error.
-  int WriteExtensionFields(uint8_t* buffer, int buffer_length) const;
+  int WriteExtensionFields(uint8_t* buffer, size_t buffer_length) const;
 
   // Set the I bit in the x_field, and write PictureID to the appropriate
   // position in buffer. The function returns 0 on success, -1 otherwise.
   int WritePictureIDFields(uint8_t* x_field,
                            uint8_t* buffer,
-                           int buffer_length,
-                           int* extension_length) const;
+                           size_t buffer_length,
+                           size_t* extension_length) const;
 
   // Set the L bit in the x_field, and write Tl0PicIdx to the appropriate
   // position in buffer. The function returns 0 on success, -1 otherwise.
   int WriteTl0PicIdxFields(uint8_t* x_field,
                            uint8_t* buffer,
-                           int buffer_length,
-                           int* extension_length) const;
+                           size_t buffer_length,
+                           size_t* extension_length) const;
 
   // Set the T and K bits in the x_field, and write TID, Y and KeyIdx to the
   // appropriate position in buffer. The function returns 0 on success,
   // -1 otherwise.
   int WriteTIDAndKeyIdxFields(uint8_t* x_field,
                               uint8_t* buffer,
-                              int buffer_length,
-                              int* extension_length) const;
+                              size_t buffer_length,
+                              size_t* extension_length) const;
 
   // Write the PictureID from codec_specific_info_ to buffer. One or two
   // bytes are written, depending on magnitude of PictureID. The function
   // returns the number of bytes written.
-  int WritePictureID(uint8_t* buffer, int buffer_length) const;
+  int WritePictureID(uint8_t* buffer, size_t buffer_length) const;
 
   // Calculate and return length (octets) of the variable header fields in
   // the next header (i.e., header length in addition to vp8_header_bytes_).
-  int PayloadDescriptorExtraLength() const;
+  size_t PayloadDescriptorExtraLength() const;
 
   // Calculate and return length (octets) of PictureID field in the next
   // header. Can be 0, 1, or 2.
-  int PictureIdLength() const;
+  size_t PictureIdLength() const;
 
   // Check whether each of the optional fields will be included in the header.
   bool XFieldPresent() const;
@@ -200,16 +200,16 @@
   bool PictureIdPresent() const { return (PictureIdLength() > 0); }
 
   const uint8_t* payload_data_;
-  int payload_size_;
+  size_t payload_size_;
   RTPFragmentationHeader part_info_;
-  const int vp8_fixed_payload_descriptor_bytes_;  // Length of VP8 payload
-                                                  // descriptors's fixed part.
+  const size_t vp8_fixed_payload_descriptor_bytes_;  // Length of VP8 payload
+                                                     // descriptors' fixed part.
   const AggregationMode aggr_mode_;
   const bool balance_;
   const bool separate_first_;
   const RTPVideoHeaderVP8 hdr_info_;
-  int num_partitions_;
-  const int max_payload_len_;
+  size_t num_partitions_;
+  const size_t max_payload_len_;
   InfoQueue packets_;
   bool packets_calculated_;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
index 549512b..a62f496 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
@@ -35,25 +35,25 @@
   delete [] buffer_;
 }
 
-bool RtpFormatVp8TestHelper::Init(const int* partition_sizes,
-                                  int num_partitions) {
+bool RtpFormatVp8TestHelper::Init(const size_t* partition_sizes,
+                                  size_t num_partitions) {
   if (inited_) return false;
   fragmentation_ = new RTPFragmentationHeader;
   fragmentation_->VerifyAndAllocateFragmentationHeader(num_partitions);
   payload_size_ = 0;
   // Calculate sum payload size.
-  for (int p = 0; p < num_partitions; ++p) {
+  for (size_t p = 0; p < num_partitions; ++p) {
     payload_size_ += partition_sizes[p];
   }
   buffer_size_ = payload_size_ + 6;  // Add space for payload descriptor.
   payload_data_ = new uint8_t[payload_size_];
   buffer_ = new uint8_t[buffer_size_];
-  int j = 0;
+  size_t j = 0;
   // Loop through the partitions again.
-  for (int p = 0; p < num_partitions; ++p) {
+  for (size_t p = 0; p < num_partitions; ++p) {
     fragmentation_->fragmentationLength[p] = partition_sizes[p];
     fragmentation_->fragmentationOffset[p] = j;
-    for (int i = 0; i < partition_sizes[p]; ++i) {
+    for (size_t i = 0; i < partition_sizes[p]; ++i) {
       assert(j < payload_size_);
       payload_data_[j++] = p;  // Set the payload value to the partition index.
     }
@@ -65,14 +65,14 @@
 
 void RtpFormatVp8TestHelper::GetAllPacketsAndCheck(
     RtpPacketizerVp8* packetizer,
-    const int* expected_sizes,
+    const size_t* expected_sizes,
     const int* expected_part,
     const bool* expected_frag_start,
-    int expected_num_packets) {
+    size_t expected_num_packets) {
   ASSERT_TRUE(inited_);
   size_t send_bytes = 0;
   bool last = false;
-  for (int i = 0; i < expected_num_packets; ++i) {
+  for (size_t i = 0; i < expected_num_packets; ++i) {
     std::ostringstream ss;
     ss << "Checking packet " << i;
     SCOPED_TRACE(ss.str());
@@ -222,8 +222,8 @@
 
 // Verify that the payload (i.e., after the headers) of the packet stored in
 // buffer_ is identical to the expected (as found in data_ptr_).
-void RtpFormatVp8TestHelper::CheckPayload(int payload_end) {
-  for (int i = payload_start_; i < payload_end; ++i, ++data_ptr_)
+void RtpFormatVp8TestHelper::CheckPayload(size_t payload_end) {
+  for (size_t i = payload_start_; i < payload_end; ++i, ++data_ptr_)
     EXPECT_EQ(buffer_[i], *data_ptr_);
 }
 
@@ -236,8 +236,8 @@
 
 // Verify the contents of a packet. Check the length versus expected_bytes,
 // the header, payload, and "last" flag.
-void RtpFormatVp8TestHelper::CheckPacket(int send_bytes,
-                                         int expect_bytes,
+void RtpFormatVp8TestHelper::CheckPacket(size_t send_bytes,
+                                         size_t expect_bytes,
                                          bool last,
                                          bool frag_start) {
   EXPECT_EQ(expect_bytes, send_bytes);
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
index 22e6803..2454fb7 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
@@ -31,17 +31,17 @@
  public:
   explicit RtpFormatVp8TestHelper(const RTPVideoHeaderVP8* hdr);
   ~RtpFormatVp8TestHelper();
-  bool Init(const int* partition_sizes, int num_partitions);
+  bool Init(const size_t* partition_sizes, size_t num_partitions);
   void GetAllPacketsAndCheck(RtpPacketizerVp8* packetizer,
-                             const int* expected_sizes,
+                             const size_t* expected_sizes,
                              const int* expected_part,
                              const bool* expected_frag_start,
-                             int expected_num_packets);
+                             size_t expected_num_packets);
 
   uint8_t* payload_data() const { return payload_data_; }
-  int payload_size() const { return payload_size_; }
+  size_t payload_size() const { return payload_size_; }
   RTPFragmentationHeader* fragmentation() const { return fragmentation_; }
-  int buffer_size() const { return buffer_size_; }
+  size_t buffer_size() const { return buffer_size_; }
   void set_sloppy_partitioning(bool value) { sloppy_partitioning_ = value; }
 
  private:
@@ -49,9 +49,9 @@
   void CheckPictureID();
   void CheckTl0PicIdx();
   void CheckTIDAndKeyIdx();
-  void CheckPayload(int payload_end);
+  void CheckPayload(size_t payload_end);
   void CheckLast(bool last) const;
-  void CheckPacket(int send_bytes, int expect_bytes, bool last,
+  void CheckPacket(size_t send_bytes, size_t expect_bytes, bool last,
                    bool frag_start);
 
   uint8_t* payload_data_;
@@ -60,8 +60,8 @@
   RTPFragmentationHeader* fragmentation_;
   const RTPVideoHeaderVP8* hdr_info_;
   int payload_start_;
-  int payload_size_;
-  int buffer_size_;
+  size_t payload_size_;
+  size_t buffer_size_;
   bool sloppy_partitioning_;
   bool inited_;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
index 4382ac2..84b880d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
@@ -80,7 +80,7 @@
  protected:
   RtpPacketizerVp8Test() : helper_(NULL) {}
   virtual void TearDown() { delete helper_; }
-  bool Init(const int* partition_sizes, int num_partitions) {
+  bool Init(const size_t* partition_sizes, size_t num_partitions) {
     hdr_info_.pictureId = kNoPictureId;
     hdr_info_.nonReference = false;
     hdr_info_.temporalIdx = kNoTemporalIdx;
@@ -98,23 +98,23 @@
 };
 
 TEST_F(RtpPacketizerVp8Test, TestStrictMode) {
-  const int kSizeVector[] = {10, 8, 27};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {10, 8, 27};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 200;  // > 0x7F should produce 2-byte PictureID.
-  const int kMaxSize = 13;
+  const size_t kMaxSize = 13;
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kStrict);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // The expected sizes are obtained by running a verified good implementation.
-  const int kExpectedSizes[] = {9, 9, 12, 11, 11, 11, 10};
+  const size_t kExpectedSizes[] = {9, 9, 12, 11, 11, 11, 10};
   const int kExpectedPart[] = {0, 0, 1, 2, 2, 2, 2};
   const bool kExpectedFragStart[] = {true,  false, true, true,
                                      false, false, false};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -126,22 +126,22 @@
 }
 
 TEST_F(RtpPacketizerVp8Test, TestAggregateMode) {
-  const int kSizeVector[] = {60, 10, 10};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {60, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
-  const int kMaxSize = 25;
+  const size_t kMaxSize = 25;
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // The expected sizes are obtained by running a verified good implementation.
-  const int kExpectedSizes[] = {23, 23, 23, 23};
+  const size_t kExpectedSizes[] = {23, 23, 23, 23};
   const int kExpectedPart[] = {0, 0, 0, 1};
   const bool kExpectedFragStart[] = {true, false, false, true};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -153,22 +153,22 @@
 }
 
 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions1) {
-  const int kSizeVector[] = {1600, 200, 200, 200, 200, 200, 200, 200, 200};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {1600, 200, 200, 200, 200, 200, 200, 200, 200};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
-  const int kMaxSize = 1500;
+  const size_t kMaxSize = 1500;
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // The expected sizes are obtained by running a verified good implementation.
-  const int kExpectedSizes[] = {803, 803, 803, 803};
+  const size_t kExpectedSizes[] = {803, 803, 803, 803};
   const int kExpectedPart[] = {0, 0, 1, 5};
   const bool kExpectedFragStart[] = {true, false, true, true};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -180,22 +180,22 @@
 }
 
 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions2) {
-  const int kSizeVector[] = {1599, 200, 200, 200, 1600, 200, 200, 200, 200};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {1599, 200, 200, 200, 1600, 200, 200, 200, 200};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
-  const int kMaxSize = 1500;
+  const size_t kMaxSize = 1500;
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // The expected sizes are obtained by running a verified good implementation.
-  const int kExpectedSizes[] = {803, 802, 603, 803, 803, 803};
+  const size_t kExpectedSizes[] = {803, 802, 603, 803, 803, 803};
   const int kExpectedPart[] = {0, 0, 1, 4, 4, 5};
   const bool kExpectedFragStart[] = {true, false, true, true, false, true};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -207,22 +207,22 @@
 }
 
 TEST_F(RtpPacketizerVp8Test, TestAggregateModeTwoLargePartitions) {
-  const int kSizeVector[] = {1654, 2268};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {1654, 2268};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
-  const int kMaxSize = 1460;
+  const size_t kMaxSize = 1460;
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // The expected sizes are obtained by running a verified good implementation.
-  const int kExpectedSizes[] = {830, 830, 1137, 1137};
+  const size_t kExpectedSizes[] = {830, 830, 1137, 1137};
   const int kExpectedPart[] = {0, 0, 1, 1};
   const bool kExpectedFragStart[] = {true, false, true, false};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -235,22 +235,22 @@
 
 // Verify that EqualSize mode is forced if fragmentation info is missing.
 TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) {
-  const int kSizeVector[] = {10, 10, 10};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {10, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
-  hdr_info_.pictureId = 200;  // > 0x7F should produce 2-byte PictureID
-  const int kMaxSize = 12;    // Small enough to produce 4 packets.
+  hdr_info_.pictureId = 200;   // > 0x7F should produce 2-byte PictureID
+  const size_t kMaxSize = 12;  // Small enough to produce 4 packets.
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize);
   packetizer.SetPayloadData(
       helper_->payload_data(), helper_->payload_size(), NULL);
 
   // Expecting three full packets, and one with the remainder.
-  const int kExpectedSizes[] = {12, 11, 12, 11};
+  const size_t kExpectedSizes[] = {12, 11, 12, 11};
   const int kExpectedPart[] = {0, 0, 0, 0};  // Always 0 for equal size mode.
   // Frag start only true for first packet in equal size mode.
   const bool kExpectedFragStart[] = {true, false, false, false};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -264,22 +264,22 @@
 
 // Verify that non-reference bit is set. EqualSize mode fallback is expected.
 TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) {
-  const int kSizeVector[] = {10, 10, 10};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {10, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.nonReference = true;
-  const int kMaxSize = 25;  // Small enough to produce two packets.
+  const size_t kMaxSize = 25;  // Small enough to produce two packets.
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize);
   packetizer.SetPayloadData(
       helper_->payload_data(), helper_->payload_size(), NULL);
 
   // EqualSize mode => First packet full; other not.
-  const int kExpectedSizes[] = {16, 16};
+  const size_t kExpectedSizes[] = {16, 16};
   const int kExpectedPart[] = {0, 0};  // Always 0 for equal size mode.
   // Frag start only true for first packet in equal size mode.
   const bool kExpectedFragStart[] = {true, false};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -293,25 +293,25 @@
 
 // Verify Tl0PicIdx and TID fields, and layerSync bit.
 TEST_F(RtpPacketizerVp8Test, TestTl0PicIdxAndTID) {
-  const int kSizeVector[] = {10, 10, 10};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {10, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.tl0PicIdx = 117;
   hdr_info_.temporalIdx = 2;
   hdr_info_.layerSync = true;
   // kMaxSize is only limited by allocated buffer size.
-  const int kMaxSize = helper_->buffer_size();
+  const size_t kMaxSize = helper_->buffer_size();
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // Expect one single packet of payload_size() + 4 bytes header.
-  const int kExpectedSizes[1] = {helper_->payload_size() + 4};
+  const size_t kExpectedSizes[1] = {helper_->payload_size() + 4};
   const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
   const bool kExpectedFragStart[1] = {true};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -324,23 +324,23 @@
 
 // Verify KeyIdx field.
 TEST_F(RtpPacketizerVp8Test, TestKeyIdx) {
-  const int kSizeVector[] = {10, 10, 10};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {10, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.keyIdx = 17;
   // kMaxSize is only limited by allocated buffer size.
-  const int kMaxSize = helper_->buffer_size();
+  const size_t kMaxSize = helper_->buffer_size();
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // Expect one single packet of payload_size() + 3 bytes header.
-  const int kExpectedSizes[1] = {helper_->payload_size() + 3};
+  const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
   const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
   const bool kExpectedFragStart[1] = {true};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ -353,24 +353,24 @@
 
 // Verify TID field and KeyIdx field in combination.
 TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) {
-  const int kSizeVector[] = {10, 10, 10};
-  const int kNumPartitions = sizeof(kSizeVector) / sizeof(kSizeVector[0]);
+  const size_t kSizeVector[] = {10, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.temporalIdx = 1;
   hdr_info_.keyIdx = 5;
   // kMaxSize is only limited by allocated buffer size.
-  const int kMaxSize = helper_->buffer_size();
+  const size_t kMaxSize = helper_->buffer_size();
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate);
   packetizer.SetPayloadData(helper_->payload_data(),
                             helper_->payload_size(),
                             helper_->fragmentation());
 
   // Expect one single packet of payload_size() + 3 bytes header.
-  const int kExpectedSizes[1] = {helper_->payload_size() + 3};
+  const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
   const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
   const bool kExpectedFragStart[1] = {true};
-  const int kExpectedNum = sizeof(kExpectedSizes) / sizeof(kExpectedSizes[0]);
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc
index 9a1836e..a19eeaa 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc
@@ -105,9 +105,9 @@
   return -1;
 }
 
-uint16_t RtpHeaderExtensionMap::GetTotalLengthInBytes() const {
+size_t RtpHeaderExtensionMap::GetTotalLengthInBytes() const {
   // Get length for each extension block.
-  uint16_t length = 0;
+  size_t length = 0;
   std::map<uint8_t, HeaderExtension*>::const_iterator it =
       extensionMap_.begin();
   while (it != extensionMap_.end()) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h
index edffe8a..335d0a1 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h
@@ -68,7 +68,7 @@
 
   int32_t GetId(const RTPExtensionType type, uint8_t* id) const;
 
-  uint16_t GetTotalLengthInBytes() const;
+  size_t GetTotalLengthInBytes() const;
 
   int32_t GetLengthUntilBlockStartInBytes(const RTPExtensionType type) const;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc
index 90d3f64..d8387e8 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc
@@ -59,7 +59,7 @@
 }
 
 TEST_F(RtpHeaderExtensionTest, GetTotalLength) {
-  EXPECT_EQ(0, map_.GetTotalLengthInBytes());
+  EXPECT_EQ(0u, map_.GetTotalLengthInBytes());
   EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
             map_.GetTotalLengthInBytes());
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
index e3515f4..2546ac0 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
@@ -94,7 +94,7 @@
 }
 
 // private, lock should already be taken
-void RTPPacketHistory::VerifyAndAllocatePacketLength(uint16_t packet_length) {
+void RTPPacketHistory::VerifyAndAllocatePacketLength(size_t packet_length) {
   assert(packet_length > 0);
   if (!store_) {
     return;
@@ -112,8 +112,8 @@
 }
 
 int32_t RTPPacketHistory::PutRTPPacket(const uint8_t* packet,
-                                       uint16_t packet_length,
-                                       uint16_t max_packet_length,
+                                       size_t packet_length,
+                                       size_t max_packet_length,
                                        int64_t capture_time_ms,
                                        StorageType type) {
   if (type == kDontStore) {
@@ -169,7 +169,7 @@
     return false;
   }
 
-  uint16_t length = stored_lengths_.at(index);
+  size_t length = stored_lengths_.at(index);
   if (length == 0 || length > max_packet_length_) {
     // Invalid length.
     return false;
@@ -181,7 +181,7 @@
                                                uint32_t min_elapsed_time_ms,
                                                bool retransmit,
                                                uint8_t* packet,
-                                               uint16_t* packet_length,
+                                               size_t* packet_length,
                                                int64_t* stored_time_ms) {
   assert(*packet_length >= max_packet_length_);
   CriticalSectionScoped cs(critsect_);
@@ -196,7 +196,7 @@
     return false;
   }
 
-  uint16_t length = stored_lengths_.at(index);
+  size_t length = stored_lengths_.at(index);
   assert(length <= max_packet_length_);
   if (length == 0) {
     LOG(LS_WARNING) << "No match for getting seqNum " << sequence_number
@@ -223,10 +223,10 @@
 
 void RTPPacketHistory::GetPacket(int index,
                                  uint8_t* packet,
-                                 uint16_t* packet_length,
+                                 size_t* packet_length,
                                  int64_t* stored_time_ms) const {
   // Get packet.
-  uint16_t length = stored_lengths_.at(index);
+  size_t length = stored_lengths_.at(index);
   std::vector<std::vector<uint8_t> >::const_iterator it_found_packet =
       stored_packets_.begin() + index;
   std::copy(it_found_packet->begin(), it_found_packet->begin() + length,
@@ -236,7 +236,7 @@
 }
 
 bool RTPPacketHistory::GetBestFittingPacket(uint8_t* packet,
-                                            uint16_t* packet_length,
+                                            size_t* packet_length,
                                             int64_t* stored_time_ms) {
   CriticalSectionScoped cs(critsect_);
   if (!store_)
@@ -283,22 +283,21 @@
   return false;
 }
 
-int RTPPacketHistory::FindBestFittingPacket(uint16_t size) const {
+int RTPPacketHistory::FindBestFittingPacket(size_t size) const {
   if (size < kMinPacketRequestBytes || stored_lengths_.empty())
     return -1;
-  int min_diff = -1;
-  size_t best_index = 0;
+  size_t min_diff = std::numeric_limits<size_t>::max();
+  int best_index = -1;  // Returned unchanged if we don't find anything.
   for (size_t i = 0; i < stored_lengths_.size(); ++i) {
     if (stored_lengths_[i] == 0)
       continue;
-    int diff = abs(stored_lengths_[i] - size);
-    if (min_diff < 0 || diff < min_diff) {
+    size_t diff = (stored_lengths_[i] > size) ?
+        (stored_lengths_[i] - size) : (size - stored_lengths_[i]);
+    if (diff < min_diff) {
       min_diff = diff;
-      best_index = i;
+      best_index = static_cast<int>(i);
     }
   }
-  if (min_diff < 0)
-    return -1;
   return best_index;
 }
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
index 253f6d0..eea3f12 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
@@ -36,8 +36,8 @@
 
   // Stores RTP packet.
   int32_t PutRTPPacket(const uint8_t* packet,
-                       uint16_t packet_length,
-                       uint16_t max_packet_length,
+                       size_t packet_length,
+                       size_t max_packet_length,
                        int64_t capture_time_ms,
                        StorageType type);
 
@@ -56,33 +56,33 @@
                                uint32_t min_elapsed_time_ms,
                                bool retransmit,
                                uint8_t* packet,
-                               uint16_t* packet_length,
+                               size_t* packet_length,
                                int64_t* stored_time_ms);
 
-  bool GetBestFittingPacket(uint8_t* packet, uint16_t* packet_length,
+  bool GetBestFittingPacket(uint8_t* packet, size_t* packet_length,
                             int64_t* stored_time_ms);
 
   bool HasRTPPacket(uint16_t sequence_number) const;
 
  private:
-  void GetPacket(int index, uint8_t* packet, uint16_t* packet_length,
+  void GetPacket(int index, uint8_t* packet, size_t* packet_length,
                  int64_t* stored_time_ms) const;
   void Allocate(uint16_t number_to_store) EXCLUSIVE_LOCKS_REQUIRED(*critsect_);
   void Free() EXCLUSIVE_LOCKS_REQUIRED(*critsect_);
-  void VerifyAndAllocatePacketLength(uint16_t packet_length);
+  void VerifyAndAllocatePacketLength(size_t packet_length);
   bool FindSeqNum(uint16_t sequence_number, int32_t* index) const;
-  int FindBestFittingPacket(uint16_t size) const;
+  int FindBestFittingPacket(size_t size) const;
 
  private:
   Clock* clock_;
   CriticalSectionWrapper* critsect_;
   bool store_;
   uint32_t prev_index_;
-  uint16_t max_packet_length_;
+  size_t max_packet_length_;
 
   std::vector<std::vector<uint8_t> > stored_packets_;
   std::vector<uint16_t> stored_seq_nums_;
-  std::vector<uint16_t> stored_lengths_;
+  std::vector<size_t> stored_lengths_;
   std::vector<int64_t> stored_times_;
   std::vector<int64_t> stored_send_times_;
   std::vector<StorageType> stored_types_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
index 7eb22ff..76798b6 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
@@ -40,7 +40,7 @@
   uint8_t packet_out_[kMaxPacketLength];
 
   void CreateRtpPacket(uint16_t seq_num, uint32_t ssrc, uint8_t payload,
-      uint32_t timestamp, uint8_t* array, uint16_t* cur_pos) {
+      uint32_t timestamp, uint8_t* array, size_t* cur_pos) {
     array[(*cur_pos)++] = 0x80;
     array[(*cur_pos)++] = payload;
     array[(*cur_pos)++] = seq_num >> 8;
@@ -66,7 +66,7 @@
 
 TEST_F(RtpPacketHistoryTest, NoStoreStatus) {
   EXPECT_FALSE(hist_->StorePackets());
-  uint16_t len = 0;
+  size_t len = 0;
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
   EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, kMaxPacketLength,
@@ -80,7 +80,7 @@
 
 TEST_F(RtpPacketHistoryTest, DontStore) {
   hist_->SetStorePacketsStatus(true, 10);
-  uint16_t len = 0;
+  size_t len = 0;
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
   EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, kMaxPacketLength,
@@ -105,7 +105,7 @@
 
 TEST_F(RtpPacketHistoryTest, GetRtpPacket_NotStored) {
   hist_->SetStorePacketsStatus(true, 10);
-  uint16_t len = kMaxPacketLength;
+  size_t len = kMaxPacketLength;
   int64_t time;
   EXPECT_FALSE(hist_->GetPacketAndSetSendTime(0, 0, false, packet_, &len,
                                               &time));
@@ -113,7 +113,7 @@
 
 TEST_F(RtpPacketHistoryTest, PutRtpPacket) {
   hist_->SetStorePacketsStatus(true, 10);
-  uint16_t len = 0;
+  size_t len = 0;
   CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
 
   EXPECT_FALSE(hist_->HasRTPPacket(kSeqNum));
@@ -125,52 +125,52 @@
 
 TEST_F(RtpPacketHistoryTest, GetRtpPacket) {
   hist_->SetStorePacketsStatus(true, 10);
-  uint16_t len = 0;
+  size_t len = 0;
   int64_t capture_time_ms = 1;
   CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
   EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, kMaxPacketLength,
                                    capture_time_ms, kAllowRetransmission));
 
-  uint16_t len_out = kMaxPacketLength;
+  size_t len_out = kMaxPacketLength;
   int64_t time;
   EXPECT_TRUE(hist_->GetPacketAndSetSendTime(kSeqNum, 0, false, packet_out_,
                                              &len_out, &time));
   EXPECT_EQ(len, len_out);
   EXPECT_EQ(capture_time_ms, time);
-  for (int i = 0; i < len; i++)  {
+  for (size_t i = 0; i < len; i++)  {
     EXPECT_EQ(packet_[i], packet_out_[i]);
   }
 }
 
 TEST_F(RtpPacketHistoryTest, NoCaptureTime) {
   hist_->SetStorePacketsStatus(true, 10);
-  uint16_t len = 0;
+  size_t len = 0;
   fake_clock_.AdvanceTimeMilliseconds(1);
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
   EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, kMaxPacketLength,
                                    -1, kAllowRetransmission));
 
-  uint16_t len_out = kMaxPacketLength;
+  size_t len_out = kMaxPacketLength;
   int64_t time;
   EXPECT_TRUE(hist_->GetPacketAndSetSendTime(kSeqNum, 0, false, packet_out_,
                                              &len_out, &time));
   EXPECT_EQ(len, len_out);
   EXPECT_EQ(capture_time_ms, time);
-  for (int i = 0; i < len; i++)  {
+  for (size_t i = 0; i < len; i++)  {
     EXPECT_EQ(packet_[i], packet_out_[i]);
   }
 }
 
 TEST_F(RtpPacketHistoryTest, DontRetransmit) {
   hist_->SetStorePacketsStatus(true, 10);
-  uint16_t len = 0;
+  size_t len = 0;
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
   EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, kMaxPacketLength,
                                    capture_time_ms, kDontRetransmit));
 
-  uint16_t len_out = kMaxPacketLength;
+  size_t len_out = kMaxPacketLength;
   int64_t time;
   EXPECT_TRUE(hist_->GetPacketAndSetSendTime(kSeqNum, 0, false, packet_out_,
                                              &len_out, &time));
@@ -180,7 +180,7 @@
 
 TEST_F(RtpPacketHistoryTest, MinResendTime) {
   hist_->SetStorePacketsStatus(true, 10);
-  uint16_t len = 0;
+  size_t len = 0;
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
   EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, kMaxPacketLength,
@@ -195,7 +195,7 @@
   len = kMaxPacketLength;
   EXPECT_TRUE(hist_->GetPacketAndSetSendTime(kSeqNum, 100, false, packet_, &len,
                                              &time));
-  EXPECT_GT(len, 0);
+  EXPECT_GT(len, 0u);
   EXPECT_EQ(capture_time_ms, time);
 
   // Time has not elapsed. Packet should be found, but no bytes copied.
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
index ec05a73..6073016 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
@@ -242,7 +242,7 @@
 
 bool RTPPayloadRegistry::RestoreOriginalPacket(uint8_t** restored_packet,
                                                const uint8_t* packet,
-                                               int* packet_length,
+                                               size_t* packet_length,
                                                uint32_t original_ssrc,
                                                const RTPHeader& header) const {
   if (kRtxHeaderSize + header.headerLength > *packet_length) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc
index 05eefbe..7e37528 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc
@@ -184,7 +184,7 @@
                                          const PayloadUnion& specific_payload,
                                          bool is_red,
                                          const uint8_t* payload,
-                                         uint16_t payload_length,
+                                         size_t payload_length,
                                          int64_t timestamp_ms,
                                          bool is_first_packet) {
   TRACE_EVENT2("webrtc_rtp", "Audio::ParseRtp",
@@ -288,7 +288,7 @@
 int32_t RTPReceiverAudio::ParseAudioCodecSpecific(
     WebRtcRTPHeader* rtp_header,
     const uint8_t* payload_data,
-    uint16_t payload_length,
+    size_t payload_length,
     const AudioPayload& audio_specific,
     bool is_red) {
 
@@ -311,13 +311,13 @@
     if (payload_length % 4 != 0) {
       return -1;
     }
-    uint8_t number_of_events = payload_length / 4;
+    size_t number_of_events = payload_length / 4;
 
     // sanity
     if (number_of_events >= MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS) {
       number_of_events = MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS;
     }
-    for (int n = 0; n < number_of_events; ++n) {
+    for (size_t n = 0; n < number_of_events; ++n) {
       bool end = (payload_data[(4 * n) + 1] & 0x80) ? true : false;
 
       std::set<uint8_t>::iterator event =
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
index 4fb7256..2c6af68 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
@@ -53,13 +53,13 @@
                       uint32_t* frequency,
                       bool* cng_payload_type_has_changed);
 
-  int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
-                         const PayloadUnion& specific_payload,
-                         bool is_red,
-                         const uint8_t* packet,
-                         uint16_t packet_length,
-                         int64_t timestamp_ms,
-                         bool is_first_packet);
+  virtual int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
+                                 const PayloadUnion& specific_payload,
+                                 bool is_red,
+                                 const uint8_t* packet,
+                                 size_t payload_length,
+                                 int64_t timestamp_ms,
+                                 bool is_first_packet) OVERRIDE;
 
   int GetPayloadTypeFrequency() const OVERRIDE;
 
@@ -104,7 +104,7 @@
   int32_t ParseAudioCodecSpecific(
       WebRtcRTPHeader* rtp_header,
       const uint8_t* payload_data,
-      uint16_t payload_length,
+      size_t payload_length,
       const AudioPayload& audio_specific,
       bool is_red);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.cc
index 22fae10..1cbc2ac 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.cc
@@ -163,12 +163,9 @@
 bool RtpReceiverImpl::IncomingRtpPacket(
   const RTPHeader& rtp_header,
   const uint8_t* payload,
-  int payload_length,
+  size_t payload_length,
   PayloadUnion payload_specific,
   bool in_order) {
-  // Sanity check.
-  assert(payload_length >= 0);
-
   // Trigger our callbacks.
   CheckSSRCChanged(rtp_header);
 
@@ -198,7 +195,7 @@
   webrtc_rtp_header.header = rtp_header;
   CheckCSRC(webrtc_rtp_header);
 
-  uint16_t payload_data_length = payload_length - rtp_header.paddingLength;
+  size_t payload_data_length = payload_length - rtp_header.paddingLength;
 
   bool is_first_packet_in_frame = false;
   {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h
index 6068811..9e58b1a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h
@@ -46,7 +46,7 @@
   virtual bool IncomingRtpPacket(
       const RTPHeader& rtp_header,
       const uint8_t* payload,
-      int payload_length,
+      size_t payload_length,
       PayloadUnion payload_specific,
       bool in_order) OVERRIDE;
 
@@ -88,7 +88,7 @@
 
   scoped_ptr<CriticalSectionWrapper> critical_section_rtp_receiver_;
   int64_t last_receive_time_;
-  uint16_t last_received_payload_length_;
+  size_t last_received_payload_length_;
 
   // SSRCs.
   uint32_t ssrc_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h
index 09c9b6f..0eb23e5 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h
@@ -43,7 +43,7 @@
                                  const PayloadUnion& specific_payload,
                                  bool is_red,
                                  const uint8_t* payload,
-                                 uint16_t payload_length,
+                                 size_t payload_length,
                                  int64_t timestamp_ms,
                                  bool is_first_packet) = 0;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc
index 6f6d647..6fe3e1d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc
@@ -51,7 +51,7 @@
                                          const PayloadUnion& specific_payload,
                                          bool is_red,
                                          const uint8_t* payload,
-                                         uint16_t payload_length,
+                                         size_t payload_length,
                                          int64_t timestamp_ms,
                                          bool is_first_packet) {
   TRACE_EVENT2("webrtc_rtp",
@@ -62,7 +62,7 @@
                rtp_header->header.timestamp);
   rtp_header->type.Video.codec = specific_payload.Video.videoCodecType;
 
-  const uint16_t payload_data_length =
+  const size_t payload_data_length =
       payload_length - rtp_header->header.paddingLength;
 
   if (payload == NULL || payload_data_length == 0) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
index 8fe4acb..177f303 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
@@ -30,7 +30,7 @@
                                  const PayloadUnion& specific_payload,
                                  bool is_red,
                                  const uint8_t* packet,
-                                 uint16_t packet_length,
+                                 size_t packet_length,
                                  int64_t timestamp,
                                  bool is_first_packet) OVERRIDE;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 6446cb7..db10956 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -259,7 +259,7 @@
 
 int32_t ModuleRtpRtcpImpl::IncomingRtcpPacket(
     const uint8_t* rtcp_packet,
-    const uint16_t length) {
+    const size_t length) {
   // Allow receive of non-compound RTCP packets.
   RTCPUtility::RTCPParserV2 rtcp_parser(rtcp_packet, length, true);
 
@@ -504,7 +504,7 @@
     uint32_t time_stamp,
     int64_t capture_time_ms,
     const uint8_t* payload_data,
-    uint32_t payload_size,
+    size_t payload_size,
     const RTPFragmentationHeader* fragmentation,
     const RTPVideoHeader* rtp_video_hdr) {
   rtcp_sender_.SetLastRtpTime(time_stamp, capture_time_ms);
@@ -603,7 +603,7 @@
   return true;
 }
 
-int ModuleRtpRtcpImpl::TimeToSendPadding(int bytes) {
+size_t ModuleRtpRtcpImpl::TimeToSendPadding(size_t bytes) {
   if (!IsDefaultModule()) {
     // Don't send from default module.
     return rtp_sender_.TimeToSendPadding(bytes);
@@ -816,7 +816,7 @@
 }
 
 int32_t ModuleRtpRtcpImpl::DataCountersRTP(
-    uint32_t* bytes_sent,
+    size_t* bytes_sent,
     uint32_t* packets_sent) const {
   StreamDataCounters rtp_stats;
   StreamDataCounters rtx_stats;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index 4975812..1b7db9f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -40,7 +40,7 @@
 
   // Called when we receive an RTCP packet.
   virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
-                                     uint16_t incoming_packet_length) OVERRIDE;
+                                     size_t incoming_packet_length) OVERRIDE;
 
   virtual void SetRemoteSSRC(const uint32_t ssrc) OVERRIDE;
 
@@ -120,7 +120,7 @@
       const uint32_t time_stamp,
       int64_t capture_time_ms,
       const uint8_t* payload_data,
-      const uint32_t payload_size,
+      const size_t payload_size,
       const RTPFragmentationHeader* fragmentation = NULL,
       const RTPVideoHeader* rtp_video_hdr = NULL) OVERRIDE;
 
@@ -130,7 +130,7 @@
                                 bool retransmission) OVERRIDE;
   // Returns the number of padding bytes actually sent, which can be more or
   // less than |bytes|.
-  virtual int TimeToSendPadding(int bytes) OVERRIDE;
+  virtual size_t TimeToSendPadding(size_t bytes) OVERRIDE;
 
   virtual bool GetSendSideDelay(int* avg_send_delay_ms,
                                 int* max_send_delay_ms) const OVERRIDE;
@@ -179,7 +179,7 @@
   virtual int32_t ResetSendDataCountersRTP() OVERRIDE;
 
   // Statistics of the amount of data sent and received.
-  virtual int32_t DataCountersRTP(uint32_t* bytes_sent,
+  virtual int32_t DataCountersRTP(size_t* bytes_sent,
                                   uint32_t* packets_sent) const OVERRIDE;
 
   // Get received RTCP report, sender info.
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
index 24ff227..bf6ab39 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
@@ -67,17 +67,17 @@
     clock_ = clock;
     delay_ms_ = delay_ms;
   }
-  virtual int SendPacket(int /*ch*/, const void* data, int len) OVERRIDE {
+  virtual int SendPacket(int /*ch*/, const void* data, size_t len) OVERRIDE {
     RTPHeader header;
     scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
-    EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data),
-                              static_cast<size_t>(len),
-                              &header));
+    EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), len, &header));
     ++rtp_packets_sent_;
     last_rtp_header_ = header;
-    return len;
+    return static_cast<int>(len);
   }
-  virtual int SendRTCPPacket(int /*ch*/, const void *data, int len) OVERRIDE {
+  virtual int SendRTCPPacket(int /*ch*/,
+                             const void *data,
+                             size_t len) OVERRIDE {
     test::RtcpPacketParser parser;
     parser.Parse(static_cast<const uint8_t*>(data), len);
     last_nack_list_ = parser.nack_item()->last_nack_list();
@@ -88,7 +88,7 @@
     EXPECT_TRUE(receiver_ != NULL);
     EXPECT_EQ(0, receiver_->IncomingRtcpPacket(
         static_cast<const uint8_t*>(data), len));
-    return len;
+    return static_cast<int>(len);
   }
   ModuleRtpRtcpImpl* receiver_;
   SimulatedClock* clock_;
@@ -398,7 +398,9 @@
  public:
   void ResetCounters() { bytes_received_.clear(); }
 
-  virtual int SendPacket(int channel, const void* data, int length) OVERRIDE {
+  virtual int SendPacket(int channel,
+                         const void* data,
+                         size_t length) OVERRIDE {
     RTPHeader header;
     scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
     EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data),
@@ -406,13 +408,13 @@
                               &header));
     bytes_received_[header.ssrc] += length;
     ++packets_received_[header.ssrc];
-    return length;
+    return static_cast<int>(length);
   }
 
   virtual int SendRTCPPacket(int channel,
                              const void* data,
-                             int length) OVERRIDE {
-    return length;
+                             size_t length) OVERRIDE {
+    return static_cast<int>(length);
   }
 
   int GetPacketsReceived(uint32_t ssrc) const {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 677f3fc..38ac859 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -22,7 +22,7 @@
 namespace webrtc {
 
 // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
-const int kMaxPaddingLength = 224;
+const size_t kMaxPaddingLength = 224;
 const int kSendSideDelayWindowMs = 1000;
 
 namespace {
@@ -272,7 +272,7 @@
   return rtp_header_extension_map_.Deregister(type);
 }
 
-uint16_t RTPSender::RtpHeaderExtensionTotalLength() const {
+size_t RTPSender::RtpHeaderExtensionTotalLength() const {
   CriticalSectionScoped cs(send_critsect_);
   return rtp_header_extension_map_.GetTotalLengthInBytes();
 }
@@ -355,7 +355,7 @@
 }
 
 int32_t RTPSender::SetMaxPayloadLength(
-    const uint16_t max_payload_length,
+    const size_t max_payload_length,
     const uint16_t packet_over_head) {
   // Sanity check.
   if (max_payload_length < 100 || max_payload_length > IP_PACKET_SIZE) {
@@ -368,7 +368,7 @@
   return 0;
 }
 
-uint16_t RTPSender::MaxDataPayloadLength() const {
+size_t RTPSender::MaxDataPayloadLength() const {
   int rtx;
   {
     CriticalSectionScoped rtx_lock(send_critsect_);
@@ -383,7 +383,7 @@
   }
 }
 
-uint16_t RTPSender::MaxPayloadLength() const {
+size_t RTPSender::MaxPayloadLength() const {
   return max_payload_length_;
 }
 
@@ -461,7 +461,7 @@
 int32_t RTPSender::SendOutgoingData(
     const FrameType frame_type, const int8_t payload_type,
     const uint32_t capture_timestamp, int64_t capture_time_ms,
-    const uint8_t *payload_data, const uint32_t payload_size,
+    const uint8_t *payload_data, const size_t payload_size,
     const RTPFragmentationHeader *fragmentation,
     VideoCodecInformation *codec_info, const RTPVideoTypeHeader *rtp_type_hdr) {
   uint32_t ssrc;
@@ -513,7 +513,7 @@
   return ret_val;
 }
 
-int RTPSender::TrySendRedundantPayloads(int bytes_to_send) {
+size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) {
   {
     CriticalSectionScoped cs(send_critsect_);
     if ((rtx_ & kRtxRedundantPayloads) == 0)
@@ -521,44 +521,41 @@
   }
 
   uint8_t buffer[IP_PACKET_SIZE];
-  int bytes_left = bytes_to_send;
+  int bytes_left = static_cast<int>(bytes_to_send);
   while (bytes_left > 0) {
-    uint16_t length = bytes_left;
+    size_t length = bytes_left;
     int64_t capture_time_ms;
     if (!packet_history_.GetBestFittingPacket(buffer, &length,
                                               &capture_time_ms)) {
       break;
     }
     if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false))
-      return -1;
+      break;
     RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
     RTPHeader rtp_header;
     rtp_parser.Parse(rtp_header);
-    bytes_left -= length - rtp_header.headerLength;
+    bytes_left -= static_cast<int>(length - rtp_header.headerLength);
   }
   return bytes_to_send - bytes_left;
 }
 
-int RTPSender::BuildPaddingPacket(uint8_t* packet, int header_length,
-                                  int32_t bytes) {
-  int padding_bytes_in_packet = kMaxPaddingLength;
-  if (bytes < kMaxPaddingLength) {
-    padding_bytes_in_packet = bytes;
-  }
+size_t RTPSender::BuildPaddingPacket(uint8_t* packet, size_t header_length) {
+  size_t padding_bytes_in_packet = kMaxPaddingLength;
   packet[0] |= 0x20;  // Set padding bit.
   int32_t *data =
       reinterpret_cast<int32_t *>(&(packet[header_length]));
 
   // Fill data buffer with random data.
-  for (int j = 0; j < (padding_bytes_in_packet >> 2); ++j) {
+  for (size_t j = 0; j < (padding_bytes_in_packet >> 2); ++j) {
     data[j] = rand();  // NOLINT
   }
   // Set number of padding bytes in the last byte of the packet.
-  packet[header_length + padding_bytes_in_packet - 1] = padding_bytes_in_packet;
+  packet[header_length + padding_bytes_in_packet - 1] =
+      static_cast<uint8_t>(padding_bytes_in_packet);
   return padding_bytes_in_packet;
 }
 
-int RTPSender::TrySendPadData(int bytes) {
+size_t RTPSender::TrySendPadData(size_t bytes) {
   int64_t capture_time_ms;
   uint32_t timestamp;
   {
@@ -575,11 +572,11 @@
   return SendPadData(timestamp, capture_time_ms, bytes);
 }
 
-int RTPSender::SendPadData(uint32_t timestamp,
-                           int64_t capture_time_ms,
-                           int32_t bytes) {
-  int padding_bytes_in_packet = 0;
-  int bytes_sent = 0;
+size_t RTPSender::SendPadData(uint32_t timestamp,
+                              int64_t capture_time_ms,
+                              size_t bytes) {
+  size_t padding_bytes_in_packet = 0;
+  size_t bytes_sent = 0;
   for (; bytes > 0; bytes -= padding_bytes_in_packet) {
     // Always send full padding packets.
     if (bytes < kMaxPaddingLength)
@@ -618,17 +615,18 @@
     }
 
     uint8_t padding_packet[IP_PACKET_SIZE];
-    int header_length = CreateRTPHeader(padding_packet,
-                                        payload_type,
-                                        ssrc,
-                                        false,
-                                        timestamp,
-                                        sequence_number,
-                                        NULL,
-                                        0);
-    padding_bytes_in_packet =
-        BuildPaddingPacket(padding_packet, header_length, bytes);
-    int length = padding_bytes_in_packet + header_length;
+    size_t header_length = CreateRTPHeader(padding_packet,
+                                           payload_type,
+                                           ssrc,
+                                           false,
+                                           timestamp,
+                                           sequence_number,
+                                           NULL,
+                                           0);
+    assert(header_length != static_cast<size_t>(-1));
+    padding_bytes_in_packet = BuildPaddingPacket(padding_packet, header_length);
+    assert(padding_bytes_in_packet <= bytes);
+    size_t length = padding_bytes_in_packet + header_length;
     int64_t now_ms = clock_->TimeInMilliseconds();
 
     RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length);
@@ -660,7 +658,7 @@
 }
 
 int32_t RTPSender::ReSendPacket(uint16_t packet_id, uint32_t min_resend_time) {
-  uint16_t length = IP_PACKET_SIZE;
+  size_t length = IP_PACKET_SIZE;
   uint8_t data_buffer[IP_PACKET_SIZE];
   int64_t capture_time_ms;
   if (!packet_history_.GetPacketAndSetSendTime(packet_id, min_resend_time, true,
@@ -695,10 +693,10 @@
   }
   return PrepareAndSendPacket(data_buffer, length, capture_time_ms,
                               (rtx & kRtxRetransmitted) > 0, true) ?
-      length : -1;
+      static_cast<int32_t>(length) : -1;
 }
 
-bool RTPSender::SendPacketToNetwork(const uint8_t *packet, uint32_t size) {
+bool RTPSender::SendPacketToNetwork(const uint8_t *packet, size_t size) {
   int bytes_sent = -1;
   if (transport_) {
     bytes_sent = transport_->SendPacket(id_, packet, size);
@@ -731,7 +729,7 @@
   TRACE_EVENT2("webrtc_rtp", "RTPSender::OnReceivedNACK",
                "num_seqnum", nack_sequence_numbers.size(), "avg_rtt", avg_rtt);
   const int64_t now = clock_->TimeInMilliseconds();
-  uint32_t bytes_re_sent = 0;
+  size_t bytes_re_sent = 0;
   uint32_t target_bitrate = GetTargetBitrate();
 
   // Enough bandwidth to send NACK?
@@ -759,8 +757,8 @@
     // Delay bandwidth estimate (RTT * BW).
     if (target_bitrate != 0 && avg_rtt) {
       // kbits/s * ms = bits => bits/8 = bytes
-      uint32_t target_bytes =
-          (static_cast<uint32_t>(target_bitrate / 1000) * avg_rtt) >> 3;
+      size_t target_bytes =
+          (static_cast<size_t>(target_bitrate / 1000) * avg_rtt) >> 3;
       if (bytes_re_sent > target_bytes) {
         break;  // Ignore the rest of the packets in the list.
       }
@@ -775,7 +773,7 @@
 
 bool RTPSender::ProcessNACKBitRate(const uint32_t now) {
   uint32_t num = 0;
-  int byte_count = 0;
+  size_t byte_count = 0;
   const uint32_t kAvgIntervalMs = 1000;
   uint32_t target_bitrate = GetTargetBitrate();
 
@@ -800,11 +798,10 @@
       time_interval = now - nack_byte_count_times_[num - 1];
     }
   }
-  return (byte_count * 8) <
-         static_cast<int>(target_bitrate / 1000 * time_interval);
+  return (byte_count * 8) < (target_bitrate / 1000 * time_interval);
 }
 
-void RTPSender::UpdateNACKBitRate(const uint32_t bytes,
+void RTPSender::UpdateNACKBitRate(const size_t bytes,
                                   const uint32_t now) {
   CriticalSectionScoped cs(send_critsect_);
 
@@ -833,7 +830,7 @@
 bool RTPSender::TimeToSendPacket(uint16_t sequence_number,
                                  int64_t capture_time_ms,
                                  bool retransmission) {
-  uint16_t length = IP_PACKET_SIZE;
+  size_t length = IP_PACKET_SIZE;
   uint8_t data_buffer[IP_PACKET_SIZE];
   int64_t stored_time_ms;
 
@@ -862,7 +859,7 @@
 }
 
 bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
-                                     uint16_t length,
+                                     size_t length,
                                      int64_t capture_time_ms,
                                      bool send_over_rtx,
                                      bool is_retransmit) {
@@ -901,7 +898,7 @@
 }
 
 void RTPSender::UpdateRtpStats(const uint8_t* buffer,
-                               uint32_t size,
+                               size_t size,
                                const RTPHeader& header,
                                bool is_rtx,
                                bool is_retransmit) {
@@ -949,22 +946,22 @@
       buffer[header.headerLength] == pt_fec;
 }
 
-int RTPSender::TimeToSendPadding(int bytes) {
+size_t RTPSender::TimeToSendPadding(size_t bytes) {
   {
     CriticalSectionScoped cs(send_critsect_);
     if (!sending_media_) return 0;
   }
-  int available_bytes = bytes;
-  if (available_bytes > 0)
-    available_bytes -= TrySendRedundantPayloads(available_bytes);
-  if (available_bytes > 0)
-    available_bytes -= TrySendPadData(available_bytes);
-  return bytes - available_bytes;
+  if (bytes == 0)
+    return 0;
+  size_t bytes_sent = TrySendRedundantPayloads(bytes);
+  if (bytes_sent < bytes)
+    bytes_sent += TrySendPadData(bytes - bytes_sent);
+  return bytes_sent;
 }
 
 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
 int32_t RTPSender::SendToNetwork(
-    uint8_t *buffer, int payload_length, int rtp_header_length,
+    uint8_t *buffer, size_t payload_length, size_t rtp_header_length,
     int64_t capture_time_ms, StorageType storage,
     PacedSender::Priority priority) {
   RtpUtility::RtpHeaderParser rtp_parser(buffer,
@@ -1013,7 +1010,7 @@
   if (capture_time_ms > 0) {
     UpdateDelayStatistics(capture_time_ms, now_ms);
   }
-  uint32_t length = payload_length + rtp_header_length;
+  size_t length = payload_length + rtp_header_length;
   if (!SendPacketToNetwork(buffer, length))
     return -1;
   {
@@ -1057,9 +1054,9 @@
   video_->ProcessBitrate();
 }
 
-uint16_t RTPSender::RTPHeaderLength() const {
+size_t RTPSender::RTPHeaderLength() const {
   CriticalSectionScoped lock(send_critsect_);
-  uint16_t rtp_header_length = 12;
+  size_t rtp_header_length = 12;
   if (include_csrcs_) {
     rtp_header_length += sizeof(uint32_t) * num_csrcs_;
   }
@@ -1326,7 +1323,7 @@
 }
 
 void RTPSender::UpdateTransmissionTimeOffset(
-    uint8_t *rtp_packet, const uint16_t rtp_packet_length,
+    uint8_t *rtp_packet, const size_t rtp_packet_length,
     const RTPHeader &rtp_header, const int64_t time_diff_ms) const {
   CriticalSectionScoped cs(send_critsect_);
   // Get id.
@@ -1345,7 +1342,7 @@
         << "Failed to update transmission time offset, not registered.";
     return;
   }
-  int block_pos = 12 + rtp_header.numCSRCs + extension_block_pos;
+  size_t block_pos = 12 + rtp_header.numCSRCs + extension_block_pos;
   if (rtp_packet_length < block_pos + kTransmissionTimeOffsetLength ||
       rtp_header.headerLength <
           block_pos + kTransmissionTimeOffsetLength) {
@@ -1372,7 +1369,7 @@
 }
 
 bool RTPSender::UpdateAudioLevel(uint8_t *rtp_packet,
-                                 const uint16_t rtp_packet_length,
+                                 const size_t rtp_packet_length,
                                  const RTPHeader &rtp_header,
                                  const bool is_voiced,
                                  const uint8_t dBov) const {
@@ -1392,7 +1389,7 @@
     // The feature is not enabled.
     return false;
   }
-  int block_pos = 12 + rtp_header.numCSRCs + extension_block_pos;
+  size_t block_pos = 12 + rtp_header.numCSRCs + extension_block_pos;
   if (rtp_packet_length < block_pos + kAudioLevelLength ||
       rtp_header.headerLength < block_pos + kAudioLevelLength) {
     LOG(LS_WARNING) << "Failed to update audio level, invalid length.";
@@ -1415,7 +1412,7 @@
 }
 
 void RTPSender::UpdateAbsoluteSendTime(
-    uint8_t *rtp_packet, const uint16_t rtp_packet_length,
+    uint8_t *rtp_packet, const size_t rtp_packet_length,
     const RTPHeader &rtp_header, const int64_t now_ms) const {
   CriticalSectionScoped cs(send_critsect_);
 
@@ -1434,7 +1431,7 @@
     // The feature is not enabled.
     return;
   }
-  int block_pos = 12 + rtp_header.numCSRCs + extension_block_pos;
+  size_t block_pos = 12 + rtp_header.numCSRCs + extension_block_pos;
   if (rtp_packet_length < block_pos + kAbsoluteSendTimeLength ||
       rtp_header.headerLength < block_pos + kAbsoluteSendTimeLength) {
     LOG(LS_WARNING) << "Failed to update absolute send time, invalid length.";
@@ -1685,7 +1682,7 @@
   return video_->SetFecParameters(delta_params, key_params);
 }
 
-void RTPSender::BuildRtxPacket(uint8_t* buffer, uint16_t* length,
+void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length,
                                uint8_t* buffer_rtx) {
   CriticalSectionScoped cs(send_critsect_);
   uint8_t* data_buffer_rtx = buffer_rtx;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
index 6564d47..4781aae 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
@@ -52,16 +52,16 @@
                                  const bool timestamp_provided = true,
                                  const bool inc_sequence_number = true) = 0;
 
-  virtual uint16_t RTPHeaderLength() const = 0;
+  virtual size_t RTPHeaderLength() const = 0;
   virtual uint16_t IncrementSequenceNumber() = 0;
   virtual uint16_t SequenceNumber() const = 0;
-  virtual uint16_t MaxPayloadLength() const = 0;
-  virtual uint16_t MaxDataPayloadLength() const = 0;
+  virtual size_t MaxPayloadLength() const = 0;
+  virtual size_t MaxDataPayloadLength() const = 0;
   virtual uint16_t PacketOverHead() const = 0;
   virtual uint16_t ActualSendBitrateKbit() const = 0;
 
   virtual int32_t SendToNetwork(
-      uint8_t *data_buffer, int payload_length, int rtp_header_length,
+      uint8_t *data_buffer, size_t payload_length, size_t rtp_header_length,
       int64_t capture_time_ms, StorageType storage,
       PacedSender::Priority priority) = 0;
 };
@@ -91,8 +91,8 @@
   void SetTargetBitrate(uint32_t bitrate);
   uint32_t GetTargetBitrate();
 
-  virtual uint16_t MaxDataPayloadLength() const
-      OVERRIDE;  // with RTP and FEC headers.
+  // Includes size of RTP and FEC headers.
+  virtual size_t MaxDataPayloadLength() const OVERRIDE;
 
   int32_t RegisterPayload(
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
@@ -133,7 +133,7 @@
   void SetCSRCs(const uint32_t arr_of_csrc[kRtpCsrcSize],
                 const uint8_t arr_length);
 
-  int32_t SetMaxPayloadLength(const uint16_t length,
+  int32_t SetMaxPayloadLength(const size_t length,
                               const uint16_t packet_over_head);
 
   int32_t SendOutgoingData(const FrameType frame_type,
@@ -141,7 +141,7 @@
                            const uint32_t timestamp,
                            int64_t capture_time_ms,
                            const uint8_t* payload_data,
-                           const uint32_t payload_size,
+                           const size_t payload_size,
                            const RTPFragmentationHeader* fragmentation,
                            VideoCodecInformation* codec_info = NULL,
                            const RTPVideoTypeHeader* rtp_type_hdr = NULL);
@@ -157,7 +157,7 @@
 
   int32_t DeregisterRtpHeaderExtension(const RTPExtensionType type);
 
-  uint16_t RtpHeaderExtensionTotalLength() const;
+  size_t RtpHeaderExtensionTotalLength() const;
 
   uint16_t BuildRTPHeaderExtension(uint8_t* data_buffer) const;
 
@@ -166,14 +166,14 @@
   uint8_t BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const;
 
   bool UpdateAudioLevel(uint8_t *rtp_packet,
-                        const uint16_t rtp_packet_length,
+                        const size_t rtp_packet_length,
                         const RTPHeader &rtp_header,
                         const bool is_voiced,
                         const uint8_t dBov) const;
 
   bool TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms,
                         bool retransmission);
-  int TimeToSendPadding(int bytes);
+  size_t TimeToSendPadding(size_t bytes);
 
   // NACK.
   int SelectiveRetransmissions() const;
@@ -210,9 +210,9 @@
       const bool timestamp_provided = true,
       const bool inc_sequence_number = true) OVERRIDE;
 
-  virtual uint16_t RTPHeaderLength() const OVERRIDE;
+  virtual size_t RTPHeaderLength() const OVERRIDE;
   virtual uint16_t IncrementSequenceNumber() OVERRIDE;
-  virtual uint16_t MaxPayloadLength() const OVERRIDE;
+  virtual size_t MaxPayloadLength() const OVERRIDE;
   virtual uint16_t PacketOverHead() const OVERRIDE;
 
   // Current timestamp.
@@ -220,7 +220,7 @@
   virtual uint32_t SSRC() const OVERRIDE;
 
   virtual int32_t SendToNetwork(
-      uint8_t *data_buffer, int payload_length, int rtp_header_length,
+      uint8_t *data_buffer, size_t payload_length, size_t rtp_header_length,
       int64_t capture_time_ms, StorageType storage,
       PacedSender::Priority priority) OVERRIDE;
 
@@ -267,9 +267,9 @@
   int32_t SetFecParameters(const FecProtectionParams *delta_params,
                            const FecProtectionParams *key_params);
 
-  int SendPadData(uint32_t timestamp,
-                  int64_t capture_time_ms,
-                  int32_t bytes);
+  size_t SendPadData(uint32_t timestamp,
+                     int64_t capture_time_ms,
+                     size_t bytes);
 
   // Called on update of RTP statistics.
   void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback);
@@ -297,38 +297,39 @@
                       uint32_t timestamp, uint16_t sequence_number,
                       const uint32_t* csrcs, uint8_t csrcs_length) const;
 
-  void UpdateNACKBitRate(const uint32_t bytes, const uint32_t now);
+  void UpdateNACKBitRate(const size_t bytes, const uint32_t now);
 
   bool PrepareAndSendPacket(uint8_t* buffer,
-                            uint16_t length,
+                            size_t length,
                             int64_t capture_time_ms,
                             bool send_over_rtx,
                             bool is_retransmit);
 
-  // Return the number of bytes sent.
-  int TrySendRedundantPayloads(int bytes);
-  int TrySendPadData(int bytes);
+  // Return the number of bytes sent.  Note that both of these functions may
+  // return a larger value that their argument.
+  size_t TrySendRedundantPayloads(size_t bytes);
+  size_t TrySendPadData(size_t bytes);
 
-  int BuildPaddingPacket(uint8_t* packet, int header_length, int32_t bytes);
+  size_t BuildPaddingPacket(uint8_t* packet, size_t header_length);
 
-  void BuildRtxPacket(uint8_t* buffer, uint16_t* length,
+  void BuildRtxPacket(uint8_t* buffer, size_t* length,
                       uint8_t* buffer_rtx);
 
-  bool SendPacketToNetwork(const uint8_t *packet, uint32_t size);
+  bool SendPacketToNetwork(const uint8_t *packet, size_t size);
 
   void UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms);
 
   void UpdateTransmissionTimeOffset(uint8_t *rtp_packet,
-                                    const uint16_t rtp_packet_length,
+                                    const size_t rtp_packet_length,
                                     const RTPHeader &rtp_header,
                                     const int64_t time_diff_ms) const;
   void UpdateAbsoluteSendTime(uint8_t *rtp_packet,
-                              const uint16_t rtp_packet_length,
+                              const size_t rtp_packet_length,
                               const RTPHeader &rtp_header,
                               const int64_t now_ms) const;
 
   void UpdateRtpStats(const uint8_t* buffer,
-                      uint32_t size,
+                      size_t size,
                       const RTPHeader& header,
                       bool is_rtx,
                       bool is_retransmit);
@@ -352,7 +353,7 @@
   Transport *transport_;
   bool sending_media_ GUARDED_BY(send_critsect_);
 
-  uint16_t max_payload_length_;
+  size_t max_payload_length_;
   uint16_t packet_over_head_;
 
   int8_t payload_type_ GUARDED_BY(send_critsect_);
@@ -364,7 +365,7 @@
 
   // NACK
   uint32_t nack_byte_count_times_[NACK_BYTECOUNT_SIZE];
-  int32_t nack_byte_count_[NACK_BYTECOUNT_SIZE];
+  size_t nack_byte_count_[NACK_BYTECOUNT_SIZE];
   Bitrate nack_bitrate_;
 
   RTPPacketHistory packet_history_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
index 7efe987..084a39c 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
@@ -233,11 +233,11 @@
     const int8_t payloadType,
     const uint32_t captureTimeStamp,
     const uint8_t* payloadData,
-    const uint32_t dataSize,
+    const size_t dataSize,
     const RTPFragmentationHeader* fragmentation) {
   // TODO(pwestin) Breakup function in smaller functions.
-  uint16_t payloadSize = static_cast<uint16_t>(dataSize);
-  uint16_t maxPayloadLength = _rtpSender->MaxPayloadLength();
+  size_t payloadSize = dataSize;
+  size_t maxPayloadLength = _rtpSender->MaxPayloadLength();
   bool dtmfToneStarted = false;
   uint16_t dtmfLengthMS = 0;
   uint8_t key = 0;
@@ -383,7 +383,7 @@
         // only 0x80 if we have multiple blocks
         dataBuffer[rtpHeaderLength++] = 0x80 +
             fragmentation->fragmentationPlType[1];
-        uint32_t blockLength = fragmentation->fragmentationLength[1];
+        size_t blockLength = fragmentation->fragmentationLength[1];
 
         // sanity blockLength
         if(blockLength > 0x3ff) {  // block length 10 bits 1023 bytes
@@ -406,9 +406,8 @@
                payloadData + fragmentation->fragmentationOffset[0],
                fragmentation->fragmentationLength[0]);
 
-        payloadSize = static_cast<uint16_t>(
-            fragmentation->fragmentationLength[0] +
-            fragmentation->fragmentationLength[1]);
+        payloadSize = fragmentation->fragmentationLength[0] +
+            fragmentation->fragmentationLength[1];
       } else {
         // silence for too long send only new data
         dataBuffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
@@ -416,8 +415,7 @@
                payloadData + fragmentation->fragmentationOffset[0],
                fragmentation->fragmentationLength[0]);
 
-        payloadSize = static_cast<uint16_t>(
-            fragmentation->fragmentationLength[0]);
+        payloadSize = fragmentation->fragmentationLength[0];
       }
     } else {
       if (fragmentation && fragmentation->fragmentationVectorSize > 0) {
@@ -427,8 +425,7 @@
                 payloadData + fragmentation->fragmentationOffset[0],
                 fragmentation->fragmentationLength[0]);
 
-        payloadSize = static_cast<uint16_t>(
-            fragmentation->fragmentationLength[0]);
+        payloadSize = fragmentation->fragmentationLength[0];
       } else {
         memcpy(dataBuffer+rtpHeaderLength, payloadData, payloadSize);
       }
@@ -437,7 +434,7 @@
 
     // Update audio level extension, if included.
     {
-      uint16_t packetSize = payloadSize + rtpHeaderLength;
+      size_t packetSize = payloadSize + rtpHeaderLength;
       RtpUtility::RtpHeaderParser rtp_parser(dataBuffer, packetSize);
       RTPHeader rtp_header;
       rtp_parser.Parse(rtp_header);
@@ -451,7 +448,7 @@
                          "seqnum", _rtpSender->SequenceNumber());
   return _rtpSender->SendToNetwork(dataBuffer,
                                    payloadSize,
-                                   static_cast<uint16_t>(rtpHeaderLength),
+                                   rtpHeaderLength,
                                    -1,
                                    kAllowRetransmission,
                                    PacedSender::kHighPriority);
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h
index d3f67e5..1affd2a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h
@@ -37,7 +37,7 @@
                       const int8_t payloadType,
                       const uint32_t captureTimeStamp,
                       const uint8_t* payloadData,
-                      const uint32_t payloadSize,
+                      const size_t payloadSize,
                       const RTPFragmentationHeader* fragmentation);
 
     // set audio packet size, used to determine when it's time to send a DTMF packet in silence (CNG)
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 2a49477..905b559 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -49,11 +49,9 @@
   return packet + rtp_header.headerLength;
 }
 
-uint16_t GetPayloadDataLength(const RTPHeader& rtp_header,
-                              const uint16_t packet_length) {
-  uint16_t length = packet_length - rtp_header.headerLength -
-      rtp_header.paddingLength;
-  return static_cast<uint16_t>(length);
+size_t GetPayloadDataLength(const RTPHeader& rtp_header,
+                            const size_t packet_length) {
+  return packet_length - rtp_header.headerLength - rtp_header.paddingLength;
 }
 
 uint64_t ConvertMsToAbsSendTime(int64_t time_ms) {
@@ -64,18 +62,20 @@
  public:
   LoopbackTransportTest()
       : packets_sent_(0), last_sent_packet_len_(0), total_bytes_sent_(0) {}
-  virtual int SendPacket(int channel, const void *data, int len) OVERRIDE {
+  virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE {
     packets_sent_++;
     memcpy(last_sent_packet_, data, len);
     last_sent_packet_len_ = len;
-    total_bytes_sent_ += static_cast<size_t>(len);
-    return len;
+    total_bytes_sent_ += len;
+    return static_cast<int>(len);
   }
-  virtual int SendRTCPPacket(int channel, const void *data, int len) OVERRIDE {
+  virtual int SendRTCPPacket(int channel,
+                             const void *data,
+                             size_t len) OVERRIDE {
     return -1;
   }
   int packets_sent_;
-  int last_sent_packet_len_;
+  size_t last_sent_packet_len_;
   size_t total_bytes_sent_;
   uint8_t last_sent_packet_[kMaxPacketLength];
 };
@@ -114,7 +114,7 @@
     EXPECT_EQ(kTimestamp, rtp_header.timestamp);
     EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
     EXPECT_EQ(0, rtp_header.numCSRCs);
-    EXPECT_EQ(0, rtp_header.paddingLength);
+    EXPECT_EQ(0U, rtp_header.paddingLength);
   }
 
   void SendPacket(int64_t capture_time_ms, int payload_length) {
@@ -124,6 +124,7 @@
                                                      kMarkerBit,
                                                      timestamp,
                                                      capture_time_ms);
+    ASSERT_GE(rtp_length, 0);
 
     // Packet should be stored in a send bucket.
     EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
@@ -136,40 +137,40 @@
 };
 
 TEST_F(RtpSenderTest, RegisterRtpTransmissionTimeOffsetHeaderExtension) {
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
             rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset));
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
 TEST_F(RtpSenderTest, RegisterRtpAbsoluteSendTimeHeaderExtension) {
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kAbsoluteSendTimeLength,
             rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
       kRtpExtensionAbsoluteSendTime));
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
 TEST_F(RtpSenderTest, RegisterRtpAudioLevelHeaderExtension) {
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAudioLevel, kAudioLevelExtensionId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kAudioLevelLength,
             rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
       kRtpExtensionAudioLevel));
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
 TEST_F(RtpSenderTest, RegisterRtpHeaderExtensions) {
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
@@ -193,16 +194,13 @@
       rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
       kRtpExtensionAudioLevel));
-  EXPECT_EQ(0, rtp_sender_->RtpHeaderExtensionTotalLength());
+  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
 TEST_F(RtpSenderTest, BuildRTPPacket) {
-  int32_t length = rtp_sender_->BuildRTPheader(packet_,
-                                               kPayload,
-                                               kMarkerBit,
-                                               kTimestamp,
-                                               0);
-  EXPECT_EQ(kRtpHeaderSize, length);
+  size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, 0));
+  ASSERT_EQ(kRtpHeaderSize, length);
 
   // Verify
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
@@ -227,13 +225,10 @@
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
 
-  int32_t length = rtp_sender_->BuildRTPheader(packet_,
-                                               kPayload,
-                                               kMarkerBit,
-                                               kTimestamp,
-                                               0);
-  EXPECT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
-      length);
+  size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, 0));
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
+            length);
 
   // Verify
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
@@ -268,13 +263,10 @@
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
 
-  int32_t length = rtp_sender_->BuildRTPheader(packet_,
-                                               kPayload,
-                                               kMarkerBit,
-                                               kTimestamp,
-                                               0);
-  EXPECT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
-      length);
+  size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, 0));
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
+            length);
 
   // Verify
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
@@ -298,13 +290,10 @@
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
 
-  int32_t length = rtp_sender_->BuildRTPheader(packet_,
-                                               kPayload,
-                                               kMarkerBit,
-                                               kTimestamp,
-                                               0);
-  EXPECT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
-      length);
+  size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, 0));
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
+            length);
 
   // Verify
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
@@ -336,13 +325,10 @@
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAudioLevel, kAudioLevelExtensionId));
 
-  int32_t length = rtp_sender_->BuildRTPheader(packet_,
-                                               kPayload,
-                                               kMarkerBit,
-                                               kTimestamp,
-                                               0);
-  EXPECT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
-      length);
+  size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, 0));
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
+            length);
 
   // Verify
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
@@ -386,13 +372,10 @@
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAudioLevel, kAudioLevelExtensionId));
 
-  int32_t length = rtp_sender_->BuildRTPheader(packet_,
-                                               kPayload,
-                                               kMarkerBit,
-                                               kTimestamp,
-                                               0);
-  EXPECT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
-      length);
+  size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, 0));
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(),
+            length);
 
   // Verify
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
@@ -447,11 +430,10 @@
       kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
   rtp_sender_->SetTargetBitrate(300000);
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
-  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
-                                                   kPayload,
-                                                   kMarkerBit,
-                                                   kTimestamp,
-                                                   capture_time_ms);
+  int rtp_length_int = rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
+  ASSERT_NE(-1, rtp_length_int);
+  size_t rtp_length = static_cast<size_t>(rtp_length_int);
 
   // Packet should be stored in a send bucket.
   EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
@@ -501,11 +483,10 @@
       kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
   rtp_sender_->SetTargetBitrate(300000);
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
-  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
-                                                   kPayload,
-                                                   kMarkerBit,
-                                                   kTimestamp,
-                                                   capture_time_ms);
+  int rtp_length_int = rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
+  ASSERT_NE(-1, rtp_length_int);
+  size_t rtp_length = static_cast<size_t>(rtp_length_int);
 
   // Packet should be stored in a send bucket.
   EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
@@ -524,7 +505,7 @@
   const int kStoredTimeInMs = 100;
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
 
-  EXPECT_EQ(rtp_length, rtp_sender_->ReSendPacket(kSeqNum));
+  EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum));
   EXPECT_EQ(0, transport_.packets_sent_);
 
   rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false);
@@ -562,7 +543,7 @@
   uint16_t seq_num = kSeqNum;
   uint32_t timestamp = kTimestamp;
   rtp_sender_->SetStorePacketsStatus(true, 10);
-  int32_t rtp_header_len = kRtpHeaderSize;
+  size_t rtp_header_len = kRtpHeaderSize;
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
@@ -583,11 +564,10 @@
 
   rtp_sender_->SetTargetBitrate(300000);
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
-  int32_t rtp_length = rtp_sender_->BuildRTPheader(packet_,
-                                                   kPayload,
-                                                   kMarkerBit,
-                                                   timestamp,
-                                                   capture_time_ms);
+  int rtp_length_int = rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
+  ASSERT_NE(-1, rtp_length_int);
+  size_t rtp_length = static_cast<size_t>(rtp_length_int);
 
   // Packet should be stored in a send bucket.
   EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
@@ -611,8 +591,8 @@
   // Send padding 4 times, waiting 50 ms between each.
   for (int i = 0; i < 4; ++i) {
     const int kPaddingPeriodMs = 50;
-    const int kPaddingBytes = 100;
-    const int kMaxPaddingLength = 224;  // Value taken from rtp_sender.cc.
+    const size_t kPaddingBytes = 100;
+    const size_t kMaxPaddingLength = 224;  // Value taken from rtp_sender.cc.
     // Padding will be forced to full packets.
     EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding(kPaddingBytes));
 
@@ -638,11 +618,10 @@
 
   // Send a regular video packet again.
   capture_time_ms = fake_clock_.TimeInMilliseconds();
-  rtp_length = rtp_sender_->BuildRTPheader(packet_,
-                                           kPayload,
-                                           kMarkerBit,
-                                           timestamp,
-                                           capture_time_ms);
+  rtp_length_int = rtp_sender_->BuildRTPheader(
+      packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
+  ASSERT_NE(-1, rtp_length_int);
+  rtp_length = static_cast<size_t>(rtp_length_int);
 
   // Packet should be stored in a send bucket.
   EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_,
@@ -716,15 +695,12 @@
   EXPECT_CALL(transport,
               SendPacket(_, _, kMaxPaddingSize + rtp_header_len))
       .WillOnce(testing::ReturnArg<2>());
-  EXPECT_EQ(kMaxPaddingSize,
-            static_cast<size_t>(rtp_sender_->TimeToSendPadding(49)));
+  EXPECT_EQ(kMaxPaddingSize, rtp_sender_->TimeToSendPadding(49));
 
-  const int kRtxHeaderSize = 2;
   EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[0] +
                                     rtp_header_len + kRtxHeaderSize))
       .WillOnce(testing::ReturnArg<2>());
-  EXPECT_EQ(kPayloadSizes[0],
-            static_cast<size_t>(rtp_sender_->TimeToSendPadding(500)));
+  EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500));
 
   EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[kNumPayloadSizes - 1] +
                                     rtp_header_len + kRtxHeaderSize))
@@ -732,7 +708,7 @@
   EXPECT_CALL(transport, SendPacket(_, _, kMaxPaddingSize + rtp_header_len))
       .WillOnce(testing::ReturnArg<2>());
   EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
-            static_cast<size_t>(rtp_sender_->TimeToSendPadding(999)));
+            rtp_sender_->TimeToSendPadding(999));
 }
 
 TEST_F(RtpSenderTest, SendGenericVideo) {
@@ -951,8 +927,8 @@
 
     uint32_t ssrc_;
     StreamDataCounters counters_;
-    bool Matches(uint32_t ssrc, uint32_t bytes, uint32_t header_bytes,
-                 uint32_t padding, uint32_t packets, uint32_t retransmits,
+    bool Matches(uint32_t ssrc, size_t bytes, size_t header_bytes,
+                 size_t padding, uint32_t packets, uint32_t retransmits,
                  uint32_t fec) {
       return ssrc_ == ssrc &&
           counters_.bytes == bytes &&
@@ -1034,8 +1010,8 @@
   const uint8_t* payload_data = GetPayloadData(rtp_header,
       transport_.last_sent_packet_);
 
-  ASSERT_EQ(sizeof(payload), GetPayloadDataLength(rtp_header,
-            transport_.last_sent_packet_len_));
+  ASSERT_EQ(sizeof(payload),
+            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
 
   EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
 }
@@ -1063,8 +1039,8 @@
   const uint8_t* payload_data = GetPayloadData(rtp_header,
                                                transport_.last_sent_packet_);
 
-  ASSERT_EQ(sizeof(payload), GetPayloadDataLength(
-      rtp_header, transport_.last_sent_packet_len_));
+  ASSERT_EQ(sizeof(payload),
+            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
 
   EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
index ec031df..4792dfa 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -100,16 +100,16 @@
 }
 
 int32_t RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
-                                        const uint16_t payload_length,
-                                        const uint16_t rtp_header_length,
+                                        const size_t payload_length,
+                                        const size_t rtp_header_length,
                                         const uint32_t capture_timestamp,
                                         int64_t capture_time_ms,
                                         StorageType storage,
                                         bool protect) {
   if (_fecEnabled) {
     int ret = 0;
-    int fec_overhead_sent = 0;
-    int video_sent = 0;
+    size_t fec_overhead_sent = 0;
+    size_t video_sent = 0;
 
     RedPacket* red_packet = producer_fec_.BuildRedPacket(
         data_buffer, payload_length, rtp_header_length, _payloadTypeRED);
@@ -202,7 +202,7 @@
   // RFC 2032
   // 5.2.1.  Full intra-frame Request (FIR) packet
 
-  uint16_t length = 8;
+  size_t length = 8;
   uint8_t data[8];
   data[0] = 0x80;
   data[1] = 192;
@@ -242,7 +242,7 @@
   return 0;
 }
 
-uint16_t RTPSenderVideo::FECPacketOverhead() const {
+size_t RTPSenderVideo::FECPacketOverhead() const {
   if (_fecEnabled) {
     // Overhead is FEC headers plus RED for FEC header plus anything in RTP
     // header beyond the 12 bytes base header (CSRC list, extensions...)
@@ -271,7 +271,7 @@
                                   const uint32_t captureTimeStamp,
                                   int64_t capture_time_ms,
                                   const uint8_t* payloadData,
-                                  const uint32_t payloadSize,
+                                  const size_t payloadSize,
                                   const RTPFragmentationHeader* fragmentation,
                                   VideoCodecInformation* codecInfo,
                                   const RTPVideoTypeHeader* rtpTypeHdr) {
@@ -320,11 +320,11 @@
                           const uint32_t captureTimeStamp,
                           int64_t capture_time_ms,
                           const uint8_t* payloadData,
-                          const uint32_t payloadSize,
+                          const size_t payloadSize,
                           const RTPFragmentationHeader* fragmentation,
                           const RTPVideoTypeHeader* rtpTypeHdr) {
   uint16_t rtp_header_length = _rtpSender.RTPHeaderLength();
-  int32_t payload_bytes_to_send = payloadSize;
+  size_t payload_bytes_to_send = payloadSize;
   const uint8_t* data = payloadData;
   size_t max_payload_length = _rtpSender.MaxDataPayloadLength();
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
index 250e36b..f043950 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.h
@@ -35,7 +35,7 @@
 
   virtual RtpVideoCodecTypes VideoCodecType() const;
 
-  uint16_t FECPacketOverhead() const;
+  size_t FECPacketOverhead() const;
 
   int32_t RegisterVideoPayload(const char payloadName[RTP_PAYLOAD_NAME_SIZE],
                                const int8_t payloadType,
@@ -48,7 +48,7 @@
                     const uint32_t captureTimeStamp,
                     int64_t capture_time_ms,
                     const uint8_t* payloadData,
-                    const uint32_t payloadSize,
+                    const size_t payloadSize,
                     const RTPFragmentationHeader* fragmentation,
                     VideoCodecInformation* codecInfo,
                     const RTPVideoTypeHeader* rtpTypeHdr);
@@ -85,8 +85,8 @@
 
  protected:
   virtual int32_t SendVideoPacket(uint8_t* dataBuffer,
-                                  const uint16_t payloadLength,
-                                  const uint16_t rtpHeaderLength,
+                                  const size_t payloadLength,
+                                  const size_t rtpHeaderLength,
                                   const uint32_t capture_timestamp,
                                   int64_t capture_time_ms,
                                   StorageType storage,
@@ -99,7 +99,7 @@
             const uint32_t captureTimeStamp,
             int64_t capture_time_ms,
             const uint8_t* payloadData,
-            const uint32_t payloadSize,
+            const size_t payloadSize,
             const RTPFragmentationHeader* fragmentation,
             const RTPVideoTypeHeader* rtpTypeHdr);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_utility.cc b/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
index 441a9c5..2897fac 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
@@ -286,7 +286,7 @@
   }
 
   const uint8_t PT = _ptrRTPDataBegin[1];
-  const uint16_t len = (_ptrRTPDataBegin[2] << 8) + _ptrRTPDataBegin[3];
+  const size_t len = (_ptrRTPDataBegin[2] << 8) + _ptrRTPDataBegin[3];
   const uint8_t* ptr = &_ptrRTPDataBegin[4];
 
   uint32_t SSRC = *ptr++ << 24;
@@ -338,7 +338,7 @@
     return false;
   }
 
-  const uint8_t CSRCocts = CC * 4;
+  const size_t CSRCocts = CC * 4;
 
   if ((ptr + CSRCocts) > _ptrRTPDataEnd) {
     return false;
@@ -352,7 +352,7 @@
   header.numCSRCs       = CC;
   header.paddingLength  = P ? *(_ptrRTPDataEnd - 1) : 0;
 
-  for (unsigned int i = 0; i < CC; ++i) {
+  for (uint8_t i = 0; i < CC; ++i) {
     uint32_t CSRC = *ptr++ << 24;
     CSRC += *ptr++ << 16;
     CSRC += *ptr++ << 8;
@@ -395,11 +395,11 @@
     uint16_t definedByProfile = *ptr++ << 8;
     definedByProfile += *ptr++;
 
-    uint16_t XLen = *ptr++ << 8;
+    size_t XLen = *ptr++ << 8;
     XLen += *ptr++; // in 32 bit words
     XLen *= 4; // in octs
 
-    if (remain < (4 + XLen)) {
+    if (static_cast<size_t>(remain) < (4 + XLen)) {
       return false;
     }
     if (definedByProfile == kRtpOneByteHeaderExtensionId) {
diff --git a/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.cc b/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.cc
index e62df1f..feed784 100644
--- a/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.cc
+++ b/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.cc
@@ -19,9 +19,9 @@
 namespace webrtc {
 
 PartitionTreeNode::PartitionTreeNode(PartitionTreeNode* parent,
-                                     const int* size_vector,
-                                     int num_partitions,
-                                     int this_size)
+                                     const size_t* size_vector,
+                                     size_t num_partitions,
+                                     size_t this_size)
     : parent_(parent),
       this_size_(this_size),
       size_vector_(size_vector),
@@ -29,13 +29,14 @@
       max_parent_size_(0),
       min_parent_size_(std::numeric_limits<int>::max()),
       packet_start_(false) {
-  assert(num_partitions >= 0);
+  // If |this_size_| > INT_MAX, Cost() and CreateChildren() won't work properly.
+  assert(this_size_ <= static_cast<size_t>(std::numeric_limits<int>::max()));
   children_[kLeftChild] = NULL;
   children_[kRightChild] = NULL;
 }
 
-PartitionTreeNode* PartitionTreeNode::CreateRootNode(const int* size_vector,
-                                                     int num_partitions) {
+PartitionTreeNode* PartitionTreeNode::CreateRootNode(const size_t* size_vector,
+                                                     size_t num_partitions) {
   PartitionTreeNode* root_node =
       new PartitionTreeNode(NULL, &size_vector[1], num_partitions - 1,
                             size_vector[0]);
@@ -48,20 +49,19 @@
   delete children_[kRightChild];
 }
 
-int PartitionTreeNode::Cost(int penalty) {
-  assert(penalty >= 0);
+int PartitionTreeNode::Cost(size_t penalty) {
   int cost = 0;
   if (num_partitions_ == 0) {
     // This is a solution node.
-    cost = std::max(max_parent_size_, this_size_) -
-        std::min(min_parent_size_, this_size_);
+    cost = std::max(max_parent_size_, this_size_int()) -
+        std::min(min_parent_size_, this_size_int());
   } else {
-    cost = std::max(max_parent_size_, this_size_) - min_parent_size_;
+    cost = std::max(max_parent_size_, this_size_int()) - min_parent_size_;
   }
   return cost + NumPackets() * penalty;
 }
 
-bool PartitionTreeNode::CreateChildren(int max_size) {
+bool PartitionTreeNode::CreateChildren(size_t max_size) {
   assert(max_size > 0);
   bool children_created = false;
   if (num_partitions_ > 0) {
@@ -85,9 +85,9 @@
                                                      num_partitions_ - 1,
                                                      size_vector_[0]);
       children_[kRightChild]->set_max_parent_size(
-          std::max(max_parent_size_, this_size_));
+          std::max(max_parent_size_, this_size_int()));
       children_[kRightChild]->set_min_parent_size(
-          std::min(min_parent_size_, this_size_));
+          std::min(min_parent_size_, this_size_int()));
       // "Right" child starts a new packet.
       children_[kRightChild]->set_packet_start(true);
       children_created = true;
@@ -96,7 +96,7 @@
   return children_created;
 }
 
-int PartitionTreeNode::NumPackets() {
+size_t PartitionTreeNode::NumPackets() {
   if (parent_ == NULL) {
     // Root node is a "right" child by definition.
     return 1;
@@ -110,8 +110,8 @@
   }
 }
 
-PartitionTreeNode* PartitionTreeNode::GetOptimalNode(int max_size,
-                                                     int penalty) {
+PartitionTreeNode* PartitionTreeNode::GetOptimalNode(size_t max_size,
+                                                     size_t penalty) {
   CreateChildren(max_size);
   PartitionTreeNode* left = children_[kLeftChild];
   PartitionTreeNode* right = children_[kRightChild];
@@ -148,12 +148,11 @@
 
 Vp8PartitionAggregator::Vp8PartitionAggregator(
     const RTPFragmentationHeader& fragmentation,
-    int first_partition_idx, int last_partition_idx)
+    size_t first_partition_idx, size_t last_partition_idx)
     : root_(NULL),
       num_partitions_(last_partition_idx - first_partition_idx + 1),
-      size_vector_(new int[num_partitions_]),
+      size_vector_(new size_t[num_partitions_]),
       largest_partition_size_(0) {
-  assert(first_partition_idx >= 0);
   assert(last_partition_idx >= first_partition_idx);
   assert(last_partition_idx < fragmentation.fragmentationVectorSize);
   for (size_t i = 0; i < num_partitions_; ++i) {
@@ -179,17 +178,18 @@
 }
 
 Vp8PartitionAggregator::ConfigVec
-Vp8PartitionAggregator::FindOptimalConfiguration(int max_size, int penalty) {
+Vp8PartitionAggregator::FindOptimalConfiguration(size_t max_size,
+                                                 size_t penalty) {
   assert(root_);
   assert(max_size >= largest_partition_size_);
   PartitionTreeNode* opt = root_->GetOptimalNode(max_size, penalty);
   ConfigVec config_vector(num_partitions_, 0);
   PartitionTreeNode* temp_node = opt;
-  int packet_index = opt->NumPackets() - 1;
-  for (int i = num_partitions_ - 1; i >= 0; --i) {
-    assert(packet_index >= 0);
+  size_t packet_index = opt->NumPackets();
+  for (size_t i = num_partitions_; i > 0; --i) {
+    assert(packet_index > 0);
     assert(temp_node != NULL);
-    config_vector[i] = packet_index;
+    config_vector[i - 1] = packet_index - 1;
     if (temp_node->packet_start()) --packet_index;
     temp_node = temp_node->parent();
   }
@@ -204,51 +204,54 @@
   if (*max_size < 0) {
     *max_size = 0;
   }
-  unsigned int i = 0;
+  size_t i = 0;
   while (i < config.size()) {
-    int this_size = 0;
-    unsigned int j = i;
+    size_t this_size = 0;
+    size_t j = i;
     while (j < config.size() && config[i] == config[j]) {
       this_size += size_vector_[j];
       ++j;
     }
     i = j;
-    if (this_size < *min_size) {
+    if (this_size < static_cast<size_t>(*min_size)) {
       *min_size = this_size;
     }
-    if (this_size > *max_size) {
+    if (this_size > static_cast<size_t>(*max_size)) {
       *max_size = this_size;
     }
   }
 }
 
-int Vp8PartitionAggregator::CalcNumberOfFragments(int large_partition_size,
-                                                  int max_payload_size,
-                                                  int penalty,
-                                                  int min_size,
-                                                  int max_size) {
-  assert(max_size <= max_payload_size);
-  assert(min_size <= max_size);
+size_t Vp8PartitionAggregator::CalcNumberOfFragments(
+    size_t large_partition_size,
+    size_t max_payload_size,
+    size_t penalty,
+    int min_size,
+    int max_size) {
+  assert(large_partition_size > 0);
   assert(max_payload_size > 0);
+  assert(min_size != 0);
+  assert(min_size <= max_size);
+  assert(max_size <= static_cast<int>(max_payload_size));
   // Divisions with rounding up.
-  const int min_number_of_fragments =
+  const size_t min_number_of_fragments =
       (large_partition_size + max_payload_size - 1) / max_payload_size;
   if (min_size < 0 || max_size < 0) {
     // No aggregates produced, so we do not have any size boundaries.
     // Simply split in as few partitions as possible.
     return min_number_of_fragments;
   }
-  const int max_number_of_fragments =
+  const size_t max_number_of_fragments =
       (large_partition_size + min_size - 1) / min_size;
   int num_fragments = -1;
-  int best_cost = std::numeric_limits<int>::max();
-  for (int n = min_number_of_fragments; n <= max_number_of_fragments; ++n) {
+  size_t best_cost = std::numeric_limits<size_t>::max();
+  for (size_t n = min_number_of_fragments; n <= max_number_of_fragments; ++n) {
     // Round up so that we use the largest fragment.
-    int fragment_size = (large_partition_size + n - 1) / n;
-    int cost = 0;
-    if (fragment_size < min_size) {
+    size_t fragment_size = (large_partition_size + n - 1) / n;
+    size_t cost = 0;
+    if (fragment_size < static_cast<size_t>(min_size)) {
       cost = min_size - fragment_size + n * penalty;
-    } else if (fragment_size > max_size) {
+    } else if (fragment_size > static_cast<size_t>(max_size)) {
       cost = fragment_size - max_size + n * penalty;
     } else {
       cost = n * penalty;
diff --git a/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.h b/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.h
index cbb1207..67babcb 100644
--- a/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.h
+++ b/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.h
@@ -24,13 +24,13 @@
  public:
   // Create a tree node.
   PartitionTreeNode(PartitionTreeNode* parent,
-                    const int* size_vector,
-                    int num_partitions,
-                    int this_size);
+                    const size_t* size_vector,
+                    size_t num_partitions,
+                    size_t this_size);
 
   // Create a root node.
-  static PartitionTreeNode* CreateRootNode(const int* size_vector,
-                                           int num_partitions);
+  static PartitionTreeNode* CreateRootNode(const size_t* size_vector,
+                                           size_t num_partitions);
 
   ~PartitionTreeNode();
 
@@ -38,18 +38,18 @@
   // will be the actual cost associated with that solution. If not, the cost
   // will be the cost accumulated so far along the current branch (which is a
   // lower bound for any solution along the branch).
-  int Cost(int penalty);
+  int Cost(size_t penalty);
 
   // Create the two children for this node.
-  bool CreateChildren(int max_size);
+  bool CreateChildren(size_t max_size);
 
   // Get the number of packets for the configuration that this node represents.
-  int NumPackets();
+  size_t NumPackets();
 
   // Find the optimal solution given a maximum packet size and a per-packet
   // penalty. The method will be recursively called while the solver is
   // probing down the tree of nodes.
-  PartitionTreeNode* GetOptimalNode(int max_size, int penalty);
+  PartitionTreeNode* GetOptimalNode(size_t max_size, size_t penalty);
 
   // Setters and getters.
   void set_max_parent_size(int size) { max_parent_size_ = size; }
@@ -57,7 +57,7 @@
   PartitionTreeNode* parent() const { return parent_; }
   PartitionTreeNode* left_child() const { return children_[kLeftChild]; }
   PartitionTreeNode* right_child() const { return children_[kRightChild]; }
-  int this_size() const { return this_size_; }
+  size_t this_size() const { return this_size_; }
   bool packet_start() const { return packet_start_; }
 
  private:
@@ -66,13 +66,14 @@
     kRightChild = 1
   };
 
+  int this_size_int() const { return static_cast<int>(this_size_); }
   void set_packet_start(bool value) { packet_start_ = value; }
 
   PartitionTreeNode* parent_;
   PartitionTreeNode* children_[2];
-  int this_size_;
-  const int* size_vector_;
-  int num_partitions_;
+  size_t this_size_;
+  const size_t* size_vector_;
+  size_t num_partitions_;
   int max_parent_size_;
   int min_parent_size_;
   bool packet_start_;
@@ -84,13 +85,14 @@
 // the maximum packet size.
 class Vp8PartitionAggregator {
  public:
-  typedef std::vector<int> ConfigVec;
+  typedef std::vector<size_t> ConfigVec;
 
   // Constructor. All partitions in the fragmentation header from index
   // first_partition_idx to last_partition_idx must be smaller than
   // maximum packet size to be used in FindOptimalConfiguration.
   Vp8PartitionAggregator(const RTPFragmentationHeader& fragmentation,
-                         int first_partition_idx, int last_partition_idx);
+                         size_t first_partition_idx,
+                         size_t last_partition_idx);
 
   ~Vp8PartitionAggregator();
 
@@ -103,7 +105,7 @@
   // first_partition_idx + 1), where each element indicates the packet index
   // for that partition. Thus, the output vector starts at 0 and is increasing
   // up to the number of packets - 1.
-  ConfigVec FindOptimalConfiguration(int max_size, int penalty);
+  ConfigVec FindOptimalConfiguration(size_t max_size, size_t penalty);
 
   // Calculate minimum and maximum packet sizes for a given aggregation config.
   // The extreme packet sizes of the given aggregation are compared with the
@@ -116,17 +118,17 @@
   // be larger than max_payload_size. Each fragment comes at an overhead cost
   // of penalty bytes. If the size of the fragments fall outside the range
   // [min_size, max_size], an extra cost is inflicted.
-  static int CalcNumberOfFragments(int large_partition_size,
-                                   int max_payload_size,
-                                   int penalty,
-                                   int min_size,
-                                   int max_size);
+  static size_t CalcNumberOfFragments(size_t large_partition_size,
+                                      size_t max_payload_size,
+                                      size_t penalty,
+                                      int min_size,
+                                      int max_size);
 
  private:
   PartitionTreeNode* root_;
   size_t num_partitions_;
-  int* size_vector_;
-  int largest_partition_size_;
+  size_t* size_vector_;
+  size_t largest_partition_size_;
 
   DISALLOW_COPY_AND_ASSIGN(Vp8PartitionAggregator);
 };
diff --git a/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator_unittest.cc b/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator_unittest.cc
index d4ebd77..4650c94 100644
--- a/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator_unittest.cc
@@ -16,8 +16,8 @@
 namespace webrtc {
 
 TEST(PartitionTreeNode, CreateAndDelete) {
-  const int kVector[] = {1, 2, 3};
-  const int kNumPartitions = sizeof(kVector) / sizeof(kVector[0]);
+  const size_t kVector[] = {1, 2, 3};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector);
   PartitionTreeNode* node1 =
       PartitionTreeNode::CreateRootNode(kVector, kNumPartitions);
   PartitionTreeNode* node2 =
@@ -27,17 +27,17 @@
 }
 
 TEST(PartitionTreeNode, CreateChildrenAndDelete) {
-  const int kVector[] = {1, 2, 3};
-  const int kNumPartitions = sizeof(kVector) / sizeof(kVector[0]);
-  const int kMaxSize = 10;
-  const int kPenalty = 5;
+  const size_t kVector[] = {1, 2, 3};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector);
+  const size_t kMaxSize = 10;
+  const size_t kPenalty = 5;
   PartitionTreeNode* root =
       PartitionTreeNode::CreateRootNode(kVector, kNumPartitions);
   EXPECT_TRUE(root->CreateChildren(kMaxSize));
   ASSERT_TRUE(NULL != root->left_child());
   ASSERT_TRUE(NULL != root->right_child());
-  EXPECT_EQ(3, root->left_child()->this_size());
-  EXPECT_EQ(2, root->right_child()->this_size());
+  EXPECT_EQ(3u, root->left_child()->this_size());
+  EXPECT_EQ(2u, root->right_child()->this_size());
   EXPECT_EQ(11, root->right_child()->Cost(kPenalty));
   EXPECT_FALSE(root->left_child()->packet_start());
   EXPECT_TRUE(root->right_child()->packet_start());
@@ -45,17 +45,17 @@
 }
 
 TEST(PartitionTreeNode, FindOptimalConfig) {
-  const int kVector[] = {197, 194, 213, 215, 184, 199, 197, 207};
-  const int kNumPartitions = sizeof(kVector) / sizeof(kVector[0]);
-  const int kMaxSize = 1500;
-  const int kPenalty = 1;
+  const size_t kVector[] = {197, 194, 213, 215, 184, 199, 197, 207};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector);
+  const size_t kMaxSize = 1500;
+  const size_t kPenalty = 1;
   PartitionTreeNode* root =
       PartitionTreeNode::CreateRootNode(kVector, kNumPartitions);
   root->set_max_parent_size(500);
   root->set_min_parent_size(300);
   PartitionTreeNode* opt = root->GetOptimalNode(kMaxSize, kPenalty);
   ASSERT_TRUE(opt != NULL);
-  EXPECT_EQ(4, opt->NumPackets());
+  EXPECT_EQ(4u, opt->NumPackets());
   // Expect optimal sequence to be {1, 0, 1, 0, 1, 0, 1, 0}, which corresponds
   // to (right)-left-right-left-right-left-right-left, where the root node is
   // implicitly a "right" node by definition.
@@ -76,23 +76,24 @@
 }
 
 TEST(PartitionTreeNode, FindOptimalConfigSinglePartition) {
-  const int kVector[] = {17};
-  const int kNumPartitions = sizeof(kVector) / sizeof(kVector[0]);
-  const int kMaxSize = 1500;
-  const int kPenalty = 1;
+  const size_t kVector[] = {17};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector);
+  const size_t kMaxSize = 1500;
+  const size_t kPenalty = 1;
   PartitionTreeNode* root =
       PartitionTreeNode::CreateRootNode(kVector, kNumPartitions);
   PartitionTreeNode* opt = root->GetOptimalNode(kMaxSize, kPenalty);
   ASSERT_TRUE(opt != NULL);
-  EXPECT_EQ(1, opt->NumPackets());
+  EXPECT_EQ(1u, opt->NumPackets());
   EXPECT_TRUE(opt == root);
   delete root;
 }
 
-static void VerifyConfiguration(const int* expected_config,
-                                size_t expected_config_len,
-                                const std::vector<int>& opt_config,
-                                const RTPFragmentationHeader& fragmentation) {
+static void VerifyConfiguration(
+    const size_t* expected_config,
+    size_t expected_config_len,
+    const Vp8PartitionAggregator::ConfigVec& opt_config,
+    const RTPFragmentationHeader& fragmentation) {
   ASSERT_EQ(expected_config_len, fragmentation.fragmentationVectorSize);
   EXPECT_EQ(expected_config_len, opt_config.size());
   for (size_t i = 0; i < expected_config_len; ++i) {
@@ -101,7 +102,7 @@
 }
 
 static void VerifyMinMax(const Vp8PartitionAggregator& aggregator,
-                         const std::vector<int>& opt_config,
+                         const Vp8PartitionAggregator::ConfigVec& opt_config,
                          int expected_min,
                          int expected_max) {
   int min_size = -1;
@@ -133,13 +134,12 @@
   Vp8PartitionAggregator* aggregator =
       new Vp8PartitionAggregator(fragmentation, 0, 7);
   aggregator->SetPriorMinMax(300, 500);
-  int kMaxSize = 1500;
-  int kPenalty = 1;
-  std::vector<int> opt_config = aggregator->FindOptimalConfiguration(kMaxSize,
-                                                                     kPenalty);
-  const int kExpectedConfig[] = {0, 0, 1, 1, 2, 2, 3, 3};
-  const size_t kExpectedConfigSize =
-      sizeof(kExpectedConfig) / sizeof(kExpectedConfig[0]);
+  size_t kMaxSize = 1500;
+  size_t kPenalty = 1;
+  Vp8PartitionAggregator::ConfigVec opt_config =
+      aggregator->FindOptimalConfiguration(kMaxSize, kPenalty);
+  const size_t kExpectedConfig[] = {0, 0, 1, 1, 2, 2, 3, 3};
+  const size_t kExpectedConfigSize = GTEST_ARRAY_SIZE_(kExpectedConfig);
   VerifyConfiguration(kExpectedConfig, kExpectedConfigSize, opt_config,
                       fragmentation);
   VerifyMinMax(*aggregator, opt_config, 383, 428);
@@ -166,13 +166,12 @@
   fragmentation.fragmentationLength[7] = 200;
   Vp8PartitionAggregator* aggregator =
       new Vp8PartitionAggregator(fragmentation, 0, 7);
-  int kMaxSize = 1500;
-  int kPenalty = 1;
-  std::vector<int> opt_config = aggregator->FindOptimalConfiguration(kMaxSize,
-                                                                     kPenalty);
-  const int kExpectedConfig[] = {0, 0, 0, 0, 1, 1, 1, 1};
-  const size_t kExpectedConfigSize =
-      sizeof(kExpectedConfig) / sizeof(kExpectedConfig[0]);
+  size_t kMaxSize = 1500;
+  size_t kPenalty = 1;
+  Vp8PartitionAggregator::ConfigVec opt_config =
+      aggregator->FindOptimalConfiguration(kMaxSize, kPenalty);
+  const size_t kExpectedConfig[] = {0, 0, 0, 0, 1, 1, 1, 1};
+  const size_t kExpectedConfigSize = GTEST_ARRAY_SIZE_(kExpectedConfig);
   VerifyConfiguration(kExpectedConfig, kExpectedConfigSize, opt_config,
                       fragmentation);
   VerifyMinMax(*aggregator, opt_config, 800, 800);
@@ -185,13 +184,12 @@
   fragmentation.fragmentationLength[0] = 17;
   Vp8PartitionAggregator* aggregator =
       new Vp8PartitionAggregator(fragmentation, 0, 0);
-  int kMaxSize = 1500;
-  int kPenalty = 1;
-  std::vector<int> opt_config = aggregator->FindOptimalConfiguration(kMaxSize,
-                                                                     kPenalty);
-  const int kExpectedConfig[] = {0};
-  const size_t kExpectedConfigSize =
-      sizeof(kExpectedConfig) / sizeof(kExpectedConfig[0]);
+  size_t kMaxSize = 1500;
+  size_t kPenalty = 1;
+  Vp8PartitionAggregator::ConfigVec opt_config =
+      aggregator->FindOptimalConfiguration(kMaxSize, kPenalty);
+  const size_t kExpectedConfig[] = {0};
+  const size_t kExpectedConfigSize = GTEST_ARRAY_SIZE_(kExpectedConfig);
   VerifyConfiguration(kExpectedConfig, kExpectedConfigSize, opt_config,
                       fragmentation);
   VerifyMinMax(*aggregator, opt_config, 17, 17);
@@ -200,13 +198,13 @@
 
 TEST(Vp8PartitionAggregator, TestCalcNumberOfFragments) {
   const int kMTU = 1500;
-  EXPECT_EQ(2,
+  EXPECT_EQ(2u,
             Vp8PartitionAggregator::CalcNumberOfFragments(
                 1600, kMTU, 1, 300, 900));
-  EXPECT_EQ(3,
+  EXPECT_EQ(3u,
             Vp8PartitionAggregator::CalcNumberOfFragments(
                 1600, kMTU, 1, 300, 798));
-  EXPECT_EQ(2,
+  EXPECT_EQ(2u,
             Vp8PartitionAggregator::CalcNumberOfFragments(
                 1600, kMTU, 1, 900, 1000));
 }
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
index 9e706e7..77ee6fb 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
@@ -33,12 +33,12 @@
 protected:
     // Inherited from UdpTransportData
     virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket,
-                                   const int32_t rtpPacketLength,
+                                   const size_t rtpPacketLength,
                                    const int8_t* fromIP,
                                    const uint16_t fromPort) OVERRIDE;
 
     virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
-                                    const int32_t rtcpPacketLength,
+                                    const size_t rtcpPacketLength,
                                     const int8_t* fromIP,
                                     const uint16_t fromPort) OVERRIDE;
 
@@ -47,21 +47,21 @@
 };
 
 void myTransportCB::IncomingRTPPacket(const int8_t* incomingRtpPacket,
-                                      const int32_t rtpPacketLength,
+                                      const size_t rtpPacketLength,
                                       const int8_t* fromIP,
                                       const uint16_t fromPort)
 {
     printf("Receiving RTP from IP %s, port %u\n", fromIP, fromPort);
-    _rtpMod->IncomingPacket((uint8_t *) incomingRtpPacket, static_cast<uint16_t>(rtpPacketLength));
+    _rtpMod->IncomingPacket((uint8_t *) incomingRtpPacket, rtpPacketLength);
 }
 
 void myTransportCB::IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
-                                       const int32_t rtcpPacketLength,
+                                       const size_t rtcpPacketLength,
                                        const int8_t* fromIP,
                                        const uint16_t fromPort)
 {
     printf("Receiving RTCP from IP %s, port %u\n", fromIP, fromPort);
-    _rtpMod->IncomingPacket((uint8_t *) incomingRtcpPacket, static_cast<uint16_t>(rtcpPacketLength));
+    _rtpMod->IncomingPacket((uint8_t *) incomingRtcpPacket, rtcpPacketLength);
 }
 
 
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
index 6a66f26..6b322f7 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
@@ -131,7 +131,7 @@
 
 int TestLoadGenerator::sendPayload (const uint32_t timeStamp,
                                     const uint8_t* payloadData,
-                                    const uint32_t payloadSize,
+                                    const size_t payloadSize,
                                     const webrtc::FrameType frameType /*= webrtc::kVideoFrameDelta*/)
 {
 
@@ -139,7 +139,10 @@
 }
 
 
-CBRGenerator::CBRGenerator (TestSenderReceiver *sender, int32_t payloadSizeBytes, int32_t bitrateKbps, int32_t rtpSampleRate)
+CBRGenerator::CBRGenerator (TestSenderReceiver *sender,
+                            size_t payloadSizeBytes,
+                            int32_t bitrateKbps,
+                            int32_t rtpSampleRate)
 :
 //_eventPtr(NULL),
 _payloadSizeBytes(payloadSizeBytes),
@@ -300,10 +303,10 @@
     return true;
 }
 
-int32_t CBRFixFRGenerator::nextPayloadSize()
+size_t CBRFixFRGenerator::nextPayloadSize()
 {
     const double periodMs = 1000.0 / _frameRateFps;
-    return static_cast<int32_t>(_bitrateKbps * periodMs / 8 + 0.5);
+    return static_cast<size_t>(_bitrateKbps * periodMs / 8 + 0.5);
 }
 
 int CBRFixFRGenerator::generatePayload ( uint32_t timestamp )
@@ -313,7 +316,7 @@
     double factor = ((double) rand() - RAND_MAX/2) / RAND_MAX; // [-0.5; 0.5]
     factor = 1 + 2 * _spreadFactor * factor; // [1 - _spreadFactor ; 1 + _spreadFactor]
 
-    int32_t thisPayloadBytes = static_cast<int32_t>(_payloadSizeBytes * factor);
+    size_t thisPayloadBytes = static_cast<size_t>(_payloadSizeBytes * factor);
     // sanity
     if (thisPayloadBytes > _payloadAllocLen)
     {
@@ -338,15 +341,17 @@
 {
 }
 
-int32_t PeriodicKeyFixFRGenerator::nextPayloadSize()
+size_t PeriodicKeyFixFRGenerator::nextPayloadSize()
 {
     // calculate payload size for a delta frame
-    int32_t payloadSizeBytes = static_cast<int32_t>(1000 * _bitrateKbps / (8.0 * _frameRateFps * (1.0 + (_keyFactor - 1.0) / _keyPeriod)) + 0.5);
+    size_t payloadSizeBytes = static_cast<size_t>(1000 * _bitrateKbps /
+        (8.0 * _frameRateFps * (1.0 + (_keyFactor - 1.0) / _keyPeriod)) + 0.5);
 
     if (_frameCount % _keyPeriod == 0)
     {
         // this is a key frame, scale the payload size
-        payloadSizeBytes = static_cast<int32_t>(_keyFactor * _payloadSizeBytes + 0.5);
+        payloadSizeBytes =
+            static_cast<size_t>(_keyFactor * _payloadSizeBytes + 0.5);
     }
     _frameCount++;
 
@@ -396,7 +401,7 @@
     printf("New frame rate: %d\n", _frameRateFps);
 }
 
-int32_t CBRVarFRGenerator::nextPayloadSize()
+size_t CBRVarFRGenerator::nextPayloadSize()
 {
     ChangeFrameRate();
     return CBRFixFRGenerator::nextPayloadSize();
@@ -416,7 +421,7 @@
 {
 }
 
-int32_t CBRFrameDropGenerator::nextPayloadSize()
+size_t CBRFrameDropGenerator::nextPayloadSize()
 {
     _accBits -= 1000 * _bitrateKbps / _frameRateFps;
     if (_accBits < 0)
@@ -432,8 +437,10 @@
     {
         //printf("keep\n");
         const double periodMs = 1000.0 / _frameRateFps;
-        int32_t frameSize = static_cast<int32_t>(_bitrateKbps * periodMs / 8 + 0.5);
-        frameSize = std::max(frameSize, static_cast<int32_t>(300 * periodMs / 8 + 0.5));
+        size_t frameSize =
+            static_cast<size_t>(_bitrateKbps * periodMs / 8 + 0.5);
+        frameSize =
+            std::max(frameSize, static_cast<size_t>(300 * periodMs / 8 + 0.5));
         _accBits += frameSize * 8;
         return frameSize;
     }
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h
index 61ebec8..fafdbf0 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.h
@@ -39,7 +39,7 @@
     int generatePayload ();
     int sendPayload (const uint32_t timeStamp,
         const uint8_t* payloadData,
-        const uint32_t payloadSize,
+        const size_t payloadSize,
         const webrtc::FrameType frameType = webrtc::kVideoFrameDelta);
 
     webrtc::CriticalSectionWrapper* _critSect;
@@ -55,7 +55,10 @@
 class CBRGenerator : public TestLoadGenerator
 {
 public:
-    CBRGenerator (TestSenderReceiver *sender, int32_t payloadSizeBytes, int32_t bitrateKbps, int32_t rtpSampleRate = 90000);
+    CBRGenerator (TestSenderReceiver *sender,
+                  size_t payloadSizeBytes,
+                  int32_t bitrateKbps,
+                  int32_t rtpSampleRate = 90000);
     virtual ~CBRGenerator ();
 
     virtual int32_t Start () {return (TestLoadGenerator::Start("CBRGenerator"));};
@@ -65,7 +68,7 @@
 protected:
     virtual int generatePayload ( uint32_t timestamp );
 
-    int32_t _payloadSizeBytes;
+    size_t _payloadSizeBytes;
     uint8_t *_payload;
 };
 
@@ -82,12 +85,12 @@
     virtual bool GeneratorLoop ();
 
 protected:
-    virtual int32_t nextPayloadSize ();
+    virtual size_t nextPayloadSize ();
     virtual int generatePayload ( uint32_t timestamp );
 
-    int32_t _payloadSizeBytes;
+    size_t _payloadSizeBytes;
     uint8_t *_payload;
-    int32_t _payloadAllocLen;
+    size_t _payloadAllocLen;
     int32_t _frameRateFps;
     double      _spreadFactor;
 };
@@ -100,7 +103,7 @@
     virtual ~PeriodicKeyFixFRGenerator () {}
 
 protected:
-    virtual int32_t nextPayloadSize ();
+    virtual size_t nextPayloadSize ();
 
     double          _keyFactor;
     uint32_t    _keyPeriod;
@@ -120,7 +123,7 @@
 
 protected:
     virtual void ChangeFrameRate();
-    virtual int32_t nextPayloadSize ();
+    virtual size_t nextPayloadSize ();
 
     double       _avgFrPeriodMs;
     double       _frSpreadFactor;
@@ -138,7 +141,7 @@
     ~CBRFrameDropGenerator();
 
 protected:
-    virtual int32_t nextPayloadSize();
+    virtual size_t nextPayloadSize();
 
     double       _accBits;
 };
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
index a536ebc..50c1981 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
@@ -256,9 +256,9 @@
 
 int32_t TestSenderReceiver::ReceiveBitrateKbps ()
 {
-    uint32_t bytesSent;
+    size_t bytesSent;
     uint32_t packetsSent;
-    uint32_t bytesReceived;
+    size_t bytesReceived;
     uint32_t packetsReceived;
 
     if (_rtp->DataCountersRTP(&bytesSent, &packetsSent, &bytesReceived, &packetsReceived) == 0)
@@ -290,7 +290,7 @@
 
 
 int32_t TestSenderReceiver::OnReceivedPayloadData(const uint8_t* payloadData,
-                                                  const uint16_t payloadSize,
+                                                  const size_t payloadSize,
                                                   const webrtc::WebRtcRTPHeader* rtpHeader)
 {
     //printf("OnReceivedPayloadData\n");
@@ -299,21 +299,21 @@
 
 
 void TestSenderReceiver::IncomingRTPPacket(const int8_t* incomingRtpPacket,
-                                      const int32_t rtpPacketLength,
-                                      const int8_t* fromIP,
-                                      const uint16_t fromPort)
+                                           const size_t rtpPacketLength,
+                                           const int8_t* fromIP,
+                                           const uint16_t fromPort)
 {
-    _rtp->IncomingPacket((uint8_t *) incomingRtpPacket, static_cast<uint16_t>(rtpPacketLength));
+    _rtp->IncomingPacket((uint8_t *) incomingRtpPacket, rtpPacketLength);
 }
 
 
 
 void TestSenderReceiver::IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
-                                       const int32_t rtcpPacketLength,
-                                       const int8_t* fromIP,
-                                       const uint16_t fromPort)
+                                            const size_t rtcpPacketLength,
+                                            const int8_t* fromIP,
+                                            const uint16_t fromPort)
 {
-    _rtp->IncomingPacket((uint8_t *) incomingRtcpPacket, static_cast<uint16_t>(rtcpPacketLength));
+    _rtp->IncomingPacket((uint8_t *) incomingRtcpPacket, rtcpPacketLength);
 }
 
 
@@ -386,7 +386,7 @@
 int32_t
 TestSenderReceiver::SendOutgoingData(const uint32_t timeStamp,
                                      const uint8_t* payloadData,
-                                     const uint32_t payloadSize,
+                                     const size_t payloadSize,
                                      const webrtc::FrameType frameType /*= webrtc::kVideoFrameDelta*/)
 {
     return (_rtp->SendOutgoingData(frameType, _payloadType, timeStamp, payloadData, payloadSize));
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
index 3968e65..30a84c9 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
@@ -90,18 +90,18 @@
     // Inherited from RtpData
     virtual int32_t OnReceivedPayloadData(
         const uint8_t* payloadData,
-        const uint16_t payloadSize,
+        const size_t payloadSize,
         const webrtc::WebRtcRTPHeader* rtpHeader) OVERRIDE;
 
 
     // Inherited from UdpTransportData
     virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket,
-                                   const int32_t rtpPacketLength,
+                                   const size_t rtpPacketLength,
                                    const int8_t* fromIP,
                                    const uint16_t fromPort) OVERRIDE;
 
     virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
-                                    const int32_t rtcpPacketLength,
+                                    const size_t rtcpPacketLength,
                                     const int8_t* fromIP,
                                     const uint16_t fromPort) OVERRIDE;
 
@@ -118,7 +118,7 @@
 
     int32_t SendOutgoingData(const uint32_t timeStamp,
         const uint8_t* payloadData,
-        const uint32_t payloadSize,
+        const size_t payloadSize,
         const webrtc::FrameType frameType = webrtc::kVideoFrameDelta);
 
     int32_t SetLoadGenerator(TestLoadGenerator *generator);
@@ -150,7 +150,7 @@
     bool _isSender;
     bool _isReceiver;
     SendRecCB * _sendRecCB;
-    uint32_t _lastBytesReceived;
+    size_t _lastBytesReceived;
     int64_t _lastTime;
 
 };
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
index bd9d197..0085641 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
@@ -43,7 +43,7 @@
   void DropEveryNthPacket(int n) {
     _packetLoss = n;
   }
-  virtual int SendPacket(int channel, const void *data, int len) OVERRIDE {
+  virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE {
     _count++;
     if (_packetLoss > 0) {
       if ((_count % _packetLoss) == 0) {
@@ -52,9 +52,7 @@
     }
     RTPHeader header;
     scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
-    if (!parser->Parse(static_cast<const uint8_t*>(data),
-                       static_cast<size_t>(len),
-                       &header)) {
+    if (!parser->Parse(static_cast<const uint8_t*>(data), len, &header)) {
       return -1;
     }
     PayloadUnion payload_specific;
@@ -70,11 +68,13 @@
     }
     return len;
   }
-  virtual int SendRTCPPacket(int channel, const void *data, int len) OVERRIDE {
+  virtual int SendRTCPPacket(int channel,
+                             const void *data,
+                             size_t len) OVERRIDE {
     if (_rtpRtcpModule->IncomingRtcpPacket((const uint8_t*)data, len) < 0) {
       return -1;
     }
-    return len;
+    return static_cast<int>(len);
   }
  private:
   int _count;
@@ -90,7 +90,7 @@
 
   virtual int32_t OnReceivedPayloadData(
       const uint8_t* payloadData,
-      const uint16_t payloadSize,
+      const size_t payloadSize,
       const webrtc::WebRtcRTPHeader* rtpHeader) OVERRIDE {
     EXPECT_LE(payloadSize, sizeof(_payloadData));
     memcpy(_payloadData, payloadData, payloadSize);
@@ -103,7 +103,7 @@
     return _payloadData;
   }
 
-  uint16_t payload_size() const {
+  size_t payload_size() const {
     return _payloadSize;
   }
 
@@ -113,7 +113,7 @@
 
  private:
   uint8_t _payloadData[1500];
-  uint16_t _payloadSize;
+  size_t _payloadSize;
   webrtc::WebRtcRTPHeader _rtpHeader;
 };
 
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
index 0832f63..49ee83a 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
@@ -27,11 +27,11 @@
  public:
   virtual int32_t OnReceivedPayloadData(
       const uint8_t* payloadData,
-      const uint16_t payloadSize,
+      const size_t payloadSize,
       const webrtc::WebRtcRTPHeader* rtpHeader) OVERRIDE {
     if (rtpHeader->header.payloadType == 98 ||
         rtpHeader->header.payloadType == 99) {
-      EXPECT_EQ(4, payloadSize);
+      EXPECT_EQ(4u, payloadSize);
       char str[5];
       memcpy(str, payloadData, payloadSize);
       str[4] = 0;
@@ -265,10 +265,10 @@
 
   RTPFragmentationHeader fragmentation;
   fragmentation.fragmentationVectorSize = 2;
-  fragmentation.fragmentationLength = new uint32_t[2];
+  fragmentation.fragmentationLength = new size_t[2];
   fragmentation.fragmentationLength[0] = 4;
   fragmentation.fragmentationLength[1] = 4;
-  fragmentation.fragmentationOffset = new uint32_t[2];
+  fragmentation.fragmentationOffset = new size_t[2];
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationOffset[1] = 4;
   fragmentation.fragmentationTimeDiff = new uint16_t[2];
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc
index 4c4944d..ddcfa96 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc
@@ -73,43 +73,42 @@
 
     payload_data_length_ = sizeof(video_frame_);
 
-    for (int n = 0; n < payload_data_length_; n++) {
+    for (size_t n = 0; n < payload_data_length_; n++) {
       video_frame_[n] = n%10;
     }
   }
 
-  int32_t BuildRTPheader(uint8_t* dataBuffer,
-                               uint32_t timestamp,
-                               uint32_t sequence_number) {
+  size_t BuildRTPheader(uint8_t* dataBuffer,
+                         uint32_t timestamp,
+                         uint32_t sequence_number) {
     dataBuffer[0] = static_cast<uint8_t>(0x80);  // version 2
     dataBuffer[1] = static_cast<uint8_t>(kPayloadType);
     RtpUtility::AssignUWord16ToBuffer(dataBuffer + 2, sequence_number);
     RtpUtility::AssignUWord32ToBuffer(dataBuffer + 4, timestamp);
     RtpUtility::AssignUWord32ToBuffer(dataBuffer + 8, 0x1234);  // SSRC.
-    int32_t rtpHeaderLength = 12;
+    size_t rtpHeaderLength = 12;
     return rtpHeaderLength;
   }
 
-  int PaddingPacket(uint8_t* buffer,
-                    uint32_t timestamp,
-                    uint32_t sequence_number,
-                    int32_t bytes) {
+  size_t PaddingPacket(uint8_t* buffer,
+                       uint32_t timestamp,
+                       uint32_t sequence_number,
+                       size_t bytes) {
     // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
-    int max_length = 224;
+    size_t max_length = 224;
 
-    int padding_bytes_in_packet = max_length;
+    size_t padding_bytes_in_packet = max_length;
     if (bytes < max_length) {
       padding_bytes_in_packet = (bytes + 16) & 0xffe0;  // Keep our modulus 32.
     }
     // Correct seq num, timestamp and payload type.
-    int header_length = BuildRTPheader(buffer, timestamp,
-                                       sequence_number);
+    size_t header_length = BuildRTPheader(buffer, timestamp, sequence_number);
     buffer[0] |= 0x20;  // Set padding bit.
     int32_t* data =
         reinterpret_cast<int32_t*>(&(buffer[header_length]));
 
     // Fill data buffer with random data.
-    for (int j = 0; j < (padding_bytes_in_packet >> 2); j++) {
+    for (size_t j = 0; j < (padding_bytes_in_packet >> 2); j++) {
       data[j] = rand();  // NOLINT
     }
     // Set number of padding bytes in the last byte of the packet.
@@ -135,7 +134,7 @@
   uint32_t test_timestamp_;
   uint16_t test_sequence_number_;
   uint8_t  video_frame_[65000];
-  int payload_data_length_;
+  size_t payload_data_length_;
   SimulatedClock fake_clock;
   enum { kPayloadType = 100 };
 };
@@ -150,7 +149,7 @@
 }
 
 TEST_F(RtpRtcpVideoTest, PaddingOnlyFrames) {
-  const int kPadSize = 255;
+  const size_t kPadSize = 255;
   uint8_t padding_packet[kPadSize];
   uint32_t seq_num = 0;
   uint32_t timestamp = 3000;
@@ -165,8 +164,8 @@
                                                      codec.maxBitrate));
   for (int frame_idx = 0; frame_idx < 10; ++frame_idx) {
     for (int packet_idx = 0; packet_idx < 5; ++packet_idx) {
-      int packet_size = PaddingPacket(padding_packet, timestamp, seq_num,
-                                      kPadSize);
+      size_t packet_size = PaddingPacket(padding_packet, timestamp, seq_num,
+                                         kPadSize);
       ++seq_num;
       RTPHeader header;
       scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
@@ -175,11 +174,11 @@
       EXPECT_TRUE(rtp_payload_registry_.GetPayloadSpecifics(header.payloadType,
                                                            &payload_specific));
       const uint8_t* payload = padding_packet + header.headerLength;
-      const int payload_length = packet_size - header.headerLength;
+      const size_t payload_length = packet_size - header.headerLength;
       EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(header, payload,
                                                    payload_length,
                                                    payload_specific, true));
-      EXPECT_EQ(0, receiver_->payload_size());
+      EXPECT_EQ(0u, receiver_->payload_size());
       EXPECT_EQ(payload_length, receiver_->rtp_header().header.paddingLength);
     }
     timestamp += 3000;
diff --git a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
index bdb53af..f1353b8 100644
--- a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
+++ b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
@@ -232,7 +232,7 @@
             for (uint32_t i = 0; i < numMediaPackets; ++i) {
               mediaPacket = new ForwardErrorCorrection::Packet;
               mediaPacketList.push_back(mediaPacket);
-              mediaPacket->length = static_cast<uint16_t>(
+              mediaPacket->length = static_cast<size_t>(
                   (static_cast<float>(rand()) / RAND_MAX) *
                   (IP_PACKET_SIZE - 12 - 28 -
                    ForwardErrorCorrection::PacketOverhead()));
@@ -264,7 +264,7 @@
                                                 timeStamp);
               RtpUtility::AssignUWord32ToBuffer(&mediaPacket->data[8], ssrc);
               // Generate random values for payload
-              for (int32_t j = 12; j < mediaPacket->length; ++j) {
+              for (size_t j = 12; j < mediaPacket->length; ++j) {
                 mediaPacket->data[j] = static_cast<uint8_t>(rand() % 256);
               }
               seqNum++;