Removing warning suppression flags from media.

Bug: webrtc:9251
Change-Id: Ifc795ca0968881e8e32ced25a04986874ba81020
Reviewed-on: https://webrtc-review.googlesource.com/78883
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23450}
diff --git a/media/BUILD.gn b/media/BUILD.gn
index 749327f..4f1689f 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -421,15 +421,6 @@
 }
 
 if (rtc_include_tests) {
-  config("rtc_unittest_main_config") {
-    # GN orders flags on a target before flags from configs. The default config
-    # adds -Wall, and this flag have to be after -Wall -- so they need to
-    # come from a config and can"t be on the target directly.
-    if (is_clang && is_ios) {
-      cflags = [ "-Wno-unused-variable" ]
-    }
-  }
-
   rtc_source_set("rtc_media_tests_utils") {
     testonly = true
 
@@ -472,8 +463,6 @@
       "engine/fakewebrtcvideoengine.h",
     ]
 
-    configs += [ ":rtc_unittest_main_config" ]
-
     if (!build_with_chromium && is_clang) {
       # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
       suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
@@ -503,24 +492,6 @@
     ]
   }
 
-  config("rtc_media_unittests_config") {
-    # GN orders flags on a target before flags from configs. The default config
-    # adds -Wall, and this flag have to be after -Wall -- so they need to
-    # come from a config and can"t be on the target directly.
-    # TODO(kjellander): Make the code compile without disabling these flags.
-    # See https://bugs.webrtc.org/3307.
-    if (is_clang && is_win) {
-      cflags = [
-        # See https://bugs.chromium.org/p/webrtc/issues/detail?id=6266
-        # for -Wno-sign-compare
-        "-Wno-sign-compare",
-      ]
-    }
-    if (!is_win) {
-      cflags = [ "-Wno-sign-compare" ]
-    }
-  }
-
   rtc_media_unittests_resources = [
     "../resources/media/captured-320x240-2s-48.frames",
     "../resources/media/faces.1280x720_P420.yuv",
@@ -594,8 +565,6 @@
       sources += [ "sctp/sctptransport_unittest.cc" ]
     }
 
-    configs += [ ":rtc_media_unittests_config" ]
-
     if (rtc_use_h264) {
       defines += [ "WEBRTC_USE_H264" ]
     }
diff --git a/media/base/codec_unittest.cc b/media/base/codec_unittest.cc
index 8fa11bf..ed4ced0 100644
--- a/media/base/codec_unittest.cc
+++ b/media/base/codec_unittest.cc
@@ -355,7 +355,7 @@
   EXPECT_EQ("V", codec_params_1.name);
   EXPECT_EQ(cricket::kVideoCodecClockrate, codec_params_1.clock_rate);
   EXPECT_EQ(rtc::nullopt, codec_params_1.num_channels);
-  ASSERT_EQ(1, codec_params_1.parameters.size());
+  ASSERT_EQ(1u, codec_params_1.parameters.size());
   EXPECT_EQ("p1", codec_params_1.parameters.begin()->first);
   EXPECT_EQ("v1", codec_params_1.parameters.begin()->second);
 
@@ -367,7 +367,7 @@
   EXPECT_EQ("A", codec_params_2.name);
   EXPECT_EQ(44100, codec_params_2.clock_rate);
   EXPECT_EQ(2, codec_params_2.num_channels);
-  ASSERT_EQ(1, codec_params_2.parameters.size());
+  ASSERT_EQ(1u, codec_params_2.parameters.size());
   EXPECT_EQ("p1", codec_params_2.parameters.begin()->first);
   EXPECT_EQ("a1", codec_params_2.parameters.begin()->second);
 }
diff --git a/media/base/turnutils_unittest.cc b/media/base/turnutils_unittest.cc
index ca12827..4a06d27 100644
--- a/media/base/turnutils_unittest.cc
+++ b/media/base/turnutils_unittest.cc
@@ -113,8 +113,8 @@
   EXPECT_TRUE(UnwrapTurnPacket(kTurnChannelMsgWithZeroLength,
                                sizeof(kTurnChannelMsgWithZeroLength),
                                &content_pos, &content_size));
-  EXPECT_EQ(4, content_pos);
-  EXPECT_EQ(0, content_size);
+  EXPECT_EQ(4u, content_pos);
+  EXPECT_EQ(0u, content_size);
 }
 
 }  // namespace cricket
diff --git a/media/engine/webrtcmediaengine_unittest.cc b/media/engine/webrtcmediaengine_unittest.cc
index 8cd8d16..446ad24 100644
--- a/media/engine/webrtcmediaengine_unittest.cc
+++ b/media/engine/webrtcmediaengine_unittest.cc
@@ -104,14 +104,14 @@
   std::vector<RtpExtension> extensions;
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions1, true);
-  EXPECT_EQ(0, filtered.size());
+  EXPECT_EQ(0u, filtered.size());
 }
 
 TEST(WebRtcMediaEngineTest, FilterRtpExtensions_IncludeOnlySupported) {
   std::vector<RtpExtension> extensions = MakeUniqueExtensions();
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions1, false);
-  EXPECT_EQ(2, filtered.size());
+  EXPECT_EQ(2u, filtered.size());
   EXPECT_EQ("c", filtered[0].uri);
   EXPECT_EQ("i", filtered[1].uri);
 }
@@ -120,7 +120,7 @@
   std::vector<RtpExtension> extensions = MakeUniqueExtensions();
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, false);
-  EXPECT_EQ(12, filtered.size());
+  EXPECT_EQ(12u, filtered.size());
   EXPECT_TRUE(IsSorted(filtered));
 }
 
@@ -128,7 +128,7 @@
   std::vector<RtpExtension> extensions = MakeUniqueExtensions();
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(12, filtered.size());
+  EXPECT_EQ(12u, filtered.size());
   EXPECT_TRUE(IsSorted(filtered));
 }
 
@@ -136,7 +136,7 @@
   std::vector<RtpExtension> extensions = MakeRedundantExtensions();
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, false);
-  EXPECT_EQ(12, filtered.size());
+  EXPECT_EQ(12u, filtered.size());
   EXPECT_TRUE(IsSorted(filtered));
   EXPECT_EQ(filtered[0].uri, filtered[1].uri);
 }
@@ -145,7 +145,7 @@
   std::vector<RtpExtension> extensions = MakeRedundantExtensions();
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(6, filtered.size());
+  EXPECT_EQ(6u, filtered.size());
   EXPECT_TRUE(IsSorted(filtered));
   EXPECT_NE(filtered[0].uri, filtered[1].uri);
 }
@@ -158,7 +158,7 @@
   extensions.push_back(webrtc::RtpExtension("b", 4));
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(3, filtered.size());
+  EXPECT_EQ(3u, filtered.size());
   EXPECT_TRUE(IsSorted(filtered));
   EXPECT_EQ(filtered[0].uri, filtered[1].uri);
   EXPECT_NE(filtered[0].encrypt, filtered[1].encrypt);
@@ -174,7 +174,7 @@
   extensions.push_back(webrtc::RtpExtension("b", 4));
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(3, filtered.size());
+  EXPECT_EQ(3u, filtered.size());
   EXPECT_TRUE(IsSorted(filtered));
   EXPECT_EQ(filtered[0].uri, filtered[1].uri);
   EXPECT_NE(filtered[0].encrypt, filtered[1].encrypt);
@@ -193,7 +193,7 @@
   extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 14));
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(1, filtered.size());
+  EXPECT_EQ(1u, filtered.size());
   EXPECT_EQ(RtpExtension::kTransportSequenceNumberUri, filtered[0].uri);
 }
 
@@ -212,7 +212,7 @@
   extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 14));
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(2, filtered.size());
+  EXPECT_EQ(2u, filtered.size());
   EXPECT_EQ(RtpExtension::kTransportSequenceNumberUri, filtered[0].uri);
   EXPECT_EQ(RtpExtension::kTransportSequenceNumberUri, filtered[1].uri);
   EXPECT_NE(filtered[0].encrypt, filtered[1].encrypt);
@@ -225,7 +225,7 @@
   extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 7));
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(1, filtered.size());
+  EXPECT_EQ(1u, filtered.size());
   EXPECT_EQ(RtpExtension::kAbsSendTimeUri, filtered[0].uri);
 }
 
@@ -235,7 +235,7 @@
   extensions.push_back(RtpExtension(RtpExtension::kTimestampOffsetUri, 14));
   std::vector<webrtc::RtpExtension> filtered =
       FilterRtpExtensions(extensions, SupportedExtensions2, true);
-  EXPECT_EQ(1, filtered.size());
+  EXPECT_EQ(1u, filtered.size());
   EXPECT_EQ(RtpExtension::kTimestampOffsetUri, filtered[0].uri);
 }
 
diff --git a/media/engine/webrtcvideoengine_unittest.cc b/media/engine/webrtcvideoengine_unittest.cc
index 7d640a6..3b23fff 100644
--- a/media/engine/webrtcvideoengine_unittest.cc
+++ b/media/engine/webrtcvideoengine_unittest.cc
@@ -39,6 +39,7 @@
 #include "media/engine/webrtcvideoengine.h"
 #include "media/engine/webrtcvoiceengine.h"
 #include "rtc_base/arraysize.h"
+#include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/stringutils.h"
 #include "test/field_trial.h"
@@ -2200,7 +2201,7 @@
         fake_call_->GetVideoSendStreams();
     EXPECT_EQ(1u, streams.size());
     FakeVideoSendStream* stream = streams[streams.size() - 1];
-    EXPECT_EQ(1, stream->GetEncoderConfig().number_of_streams);
+    EXPECT_EQ(1u, stream->GetEncoderConfig().number_of_streams);
     return stream->GetVideoStreams()[0].max_bitrate_bps;
   }
 
@@ -2238,7 +2239,7 @@
   sp.set_stream_ids({kSyncLabel});
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
-  EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size());
+  EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
   EXPECT_EQ(kSyncLabel,
             fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
       << "SyncGroup should be set based on sync_label";
@@ -2653,8 +2654,9 @@
 
   // Frame entered, should be reconfigured to new dimensions.
   streams = stream->GetVideoStreams();
-  EXPECT_EQ(capture_format.width, streams[0].width);
-  EXPECT_EQ(capture_format.height, streams[0].height);
+  EXPECT_EQ(rtc::checked_cast<size_t>(capture_format.width), streams[0].width);
+  EXPECT_EQ(rtc::checked_cast<size_t>(capture_format.height),
+            streams[0].height);
 
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
 }
@@ -2692,8 +2694,10 @@
   EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
             encoder_config.content_type);
   std::vector<webrtc::VideoStream> streams = send_stream->GetVideoStreams();
-  EXPECT_EQ(capture_format_hd.width, streams.front().width);
-  EXPECT_EQ(capture_format_hd.height, streams.front().height);
+  EXPECT_EQ(rtc::checked_cast<size_t>(capture_format_hd.width),
+            streams.front().width);
+  EXPECT_EQ(rtc::checked_cast<size_t>(capture_format_hd.height),
+            streams.front().height);
   EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
       << "Non-screenshare shouldn't use min-transmit bitrate.";
 
@@ -2717,8 +2721,10 @@
             encoder_config.min_transmit_bitrate_bps);
 
   streams = send_stream->GetVideoStreams();
-  EXPECT_EQ(capture_format_hd.width, streams.front().width);
-  EXPECT_EQ(capture_format_hd.height, streams.front().height);
+  EXPECT_EQ(rtc::checked_cast<size_t>(capture_format_hd.width),
+            streams.front().width);
+  EXPECT_EQ(rtc::checked_cast<size_t>(capture_format_hd.height),
+            streams.front().height);
   EXPECT_FALSE(streams[0].num_temporal_layers.has_value());
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr));
 }
@@ -2840,7 +2846,7 @@
   channel_->SetSend(true);
   EXPECT_TRUE(capturer.CaptureFrame());
 
-  EXPECT_EQ(3, stream->GetVideoStreams().size());
+  EXPECT_EQ(3u, stream->GetVideoStreams().size());
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   // Autmatic resize off when using simulcast.
   EXPECT_FALSE(vp8_settings.automaticResizeOn);
@@ -2853,7 +2859,7 @@
 
   stream = SetDenoisingOption(last_ssrc_, &capturer, false);
 
-  EXPECT_EQ(1, stream->GetVideoStreams().size());
+  EXPECT_EQ(1u, stream->GetVideoStreams().size());
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_FALSE(vp8_settings.denoisingOn);
   // Resizing and frame dropping always off for screen sharing.
@@ -3736,7 +3742,7 @@
   webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
 
   EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
-  EXPECT_EQ(0, config.rtp.flexfec.ssrc);
+  EXPECT_EQ(0u, config.rtp.flexfec.ssrc);
   EXPECT_TRUE(config.rtp.flexfec.protected_media_ssrcs.empty());
 }
 
@@ -3752,7 +3758,7 @@
   webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
 
   EXPECT_EQ(-1, config.rtp.flexfec.payload_type);
-  EXPECT_EQ(0, config.rtp.flexfec.ssrc);
+  EXPECT_EQ(0u, config.rtp.flexfec.ssrc);
   EXPECT_TRUE(config.rtp.flexfec.protected_media_ssrcs.empty());
 }
 
@@ -4059,7 +4065,7 @@
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
+  EXPECT_EQ(atoi(kMaxQuantization),
             AddSendStream()->GetVideoStreams().back().max_qp);
 
   VideoCodec codec;
@@ -4662,11 +4668,11 @@
   cricket::VideoMediaInfo info;
   ASSERT_TRUE(channel_->GetStats(&info));
   EXPECT_EQ(stats.rtcp_packet_type_counts.fir_packets,
-            info.receivers[0].firs_sent);
+            rtc::checked_cast<unsigned int>(info.receivers[0].firs_sent));
   EXPECT_EQ(stats.rtcp_packet_type_counts.nack_packets,
-            info.receivers[0].nacks_sent);
+            rtc::checked_cast<unsigned int>(info.receivers[0].nacks_sent));
   EXPECT_EQ(stats.rtcp_packet_type_counts.pli_packets,
-            info.receivers[0].plis_sent);
+            rtc::checked_cast<unsigned int>(info.receivers[0].plis_sent));
 }
 
 TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
@@ -4702,7 +4708,8 @@
   EXPECT_EQ(stats.render_delay_ms, info.receivers[0].render_delay_ms);
   EXPECT_EQ(stats.width, info.receivers[0].frame_width);
   EXPECT_EQ(stats.height, info.receivers[0].frame_height);
-  EXPECT_EQ(stats.frame_counts.key_frames + stats.frame_counts.delta_frames,
+  EXPECT_EQ(rtc::checked_cast<unsigned int>(stats.frame_counts.key_frames +
+                                            stats.frame_counts.delta_frames),
             info.receivers[0].frames_received);
   EXPECT_EQ(stats.frames_rendered, info.receivers[0].frames_rendered);
   EXPECT_EQ(stats.frames_decoded, info.receivers[0].frames_decoded);
@@ -4725,11 +4732,11 @@
   EXPECT_EQ(stats.rtp_stats.transmitted.payload_bytes +
                 stats.rtp_stats.transmitted.header_bytes +
                 stats.rtp_stats.transmitted.padding_bytes,
-            info.receivers[0].bytes_rcvd);
+            rtc::checked_cast<size_t>(info.receivers[0].bytes_rcvd));
   EXPECT_EQ(stats.rtp_stats.transmitted.packets,
-            info.receivers[0].packets_rcvd);
+            rtc::checked_cast<unsigned int>(info.receivers[0].packets_rcvd));
   EXPECT_EQ(stats.rtcp_stats.packets_lost, info.receivers[0].packets_lost);
-  EXPECT_EQ(static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8),
+  EXPECT_EQ(rtc::checked_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8),
             info.receivers[0].fraction_lost);
 }
 
@@ -4950,7 +4957,7 @@
   ASSERT_TRUE(channel_->AddRecvStream(unsignaled_stream));
   // The stream shouldn't have been created at this point because it doesn't
   // have any SSRCs.
-  EXPECT_EQ(0, fake_call_->GetVideoReceiveStreams().size());
+  EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
 
   // Create and deliver packet.
   const size_t kDataLength = 12;
@@ -5206,7 +5213,7 @@
 TEST_F(WebRtcVideoChannelTest, CannotSetMaxBitrateForNonexistentStream) {
   webrtc::RtpParameters nonexistent_parameters =
       channel_->GetRtpSendParameters(last_ssrc_);
-  EXPECT_EQ(0, nonexistent_parameters.encodings.size());
+  EXPECT_EQ(0u, nonexistent_parameters.encodings.size());
 
   nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
   EXPECT_FALSE(
@@ -5355,7 +5362,8 @@
   // Get and set the rtp encoding parameters.
   webrtc::RtpParameters parameters =
       channel_->GetRtpSendParameters(primary_ssrc);
-  EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            parameters.encodings.size());
   EXPECT_EQ(webrtc::kDefaultBitratePriority,
             parameters.encodings[0].bitrate_priority);
   // Change the value and set it on the VideoChannel.
@@ -5365,7 +5373,8 @@
 
   // Verify that the encoding parameters priority is set on the VideoChannel.
   parameters = channel_->GetRtpSendParameters(primary_ssrc);
-  EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            parameters.encodings.size());
   EXPECT_EQ(new_bitrate_priority, parameters.encodings[0].bitrate_priority);
 
   // Verify that the new value propagated down to the encoder.
@@ -5375,14 +5384,15 @@
   FakeVideoSendStream* video_send_stream = video_send_streams.front();
   // Check that the WebRtcVideoSendStream updated the VideoEncoderConfig
   // appropriately.
-  EXPECT_EQ(kNumSimulcastStreams,
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
             video_send_stream->GetEncoderConfig().number_of_streams);
   EXPECT_EQ(new_bitrate_priority,
             video_send_stream->GetEncoderConfig().bitrate_priority);
   // Check that the vector of VideoStreams also propagated correctly. The
   // FakeVideoSendStream calls CreateEncoderStreams, and we are testing that
   // these are created appropriately for the simulcast case.
-  EXPECT_EQ(kNumSimulcastStreams, video_send_stream->GetVideoStreams().size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            video_send_stream->GetVideoStreams().size());
   EXPECT_EQ(rtc::Optional<double>(new_bitrate_priority),
             video_send_stream->GetVideoStreams()[0].bitrate_priority);
   // Since we are only setting bitrate priority per-sender, the other
@@ -5442,7 +5452,8 @@
   // Check that all encodings are initially active.
   webrtc::RtpParameters parameters =
       channel_->GetRtpSendParameters(primary_ssrc);
-  EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            parameters.encodings.size());
   EXPECT_TRUE(parameters.encodings[0].active);
   EXPECT_TRUE(parameters.encodings[1].active);
   EXPECT_TRUE(parameters.encodings[2].active);
@@ -5455,7 +5466,8 @@
   EXPECT_TRUE(channel_->SetRtpSendParameters(primary_ssrc, parameters).ok());
   // Verify that the active fields are set on the VideoChannel.
   parameters = channel_->GetRtpSendParameters(primary_ssrc);
-  EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            parameters.encodings.size());
   EXPECT_FALSE(parameters.encodings[0].active);
   EXPECT_TRUE(parameters.encodings[1].active);
   EXPECT_FALSE(parameters.encodings[2].active);
@@ -5464,7 +5476,8 @@
   EXPECT_TRUE(fake_video_send_stream->IsSending());
   std::vector<webrtc::VideoStream> simulcast_streams =
       fake_video_send_stream->GetVideoStreams();
-  EXPECT_EQ(kNumSimulcastStreams, simulcast_streams.size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            simulcast_streams.size());
   EXPECT_FALSE(simulcast_streams[0].active);
   EXPECT_TRUE(simulcast_streams[1].active);
   EXPECT_FALSE(simulcast_streams[2].active);
@@ -5476,14 +5489,16 @@
   EXPECT_TRUE(channel_->SetRtpSendParameters(primary_ssrc, parameters).ok());
   // Verify that the active fields are set on the VideoChannel.
   parameters = channel_->GetRtpSendParameters(primary_ssrc);
-  EXPECT_EQ(kNumSimulcastStreams, parameters.encodings.size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            parameters.encodings.size());
   EXPECT_FALSE(parameters.encodings[0].active);
   EXPECT_FALSE(parameters.encodings[1].active);
   EXPECT_FALSE(parameters.encodings[2].active);
   // Check that the VideoSendStream is off.
   EXPECT_FALSE(fake_video_send_stream->IsSending());
   simulcast_streams = fake_video_send_stream->GetVideoStreams();
-  EXPECT_EQ(kNumSimulcastStreams, simulcast_streams.size());
+  EXPECT_EQ(rtc::checked_cast<size_t>(kNumSimulcastStreams),
+            simulcast_streams.size());
   EXPECT_FALSE(simulcast_streams[0].active);
   EXPECT_FALSE(simulcast_streams[1].active);
   EXPECT_FALSE(simulcast_streams[2].active);
@@ -5836,8 +5851,8 @@
       if (screenshare) {
         for (const webrtc::VideoStream& stream : expected_streams) {
           // Never scale screen content.
-          EXPECT_EQ(stream.width, capture_width);
-          EXPECT_EQ(stream.height, capture_height);
+          EXPECT_EQ(stream.width, rtc::checked_cast<size_t>(capture_width));
+          EXPECT_EQ(stream.height, rtc::checked_cast<size_t>(capture_height));
         }
       }
     } else {
diff --git a/media/engine/webrtcvoiceengine_unittest.cc b/media/engine/webrtcvoiceengine_unittest.cc
index 966ca6b..79fe7c7 100644
--- a/media/engine/webrtcvoiceengine_unittest.cc
+++ b/media/engine/webrtcvoiceengine_unittest.cc
@@ -647,17 +647,22 @@
     const auto stats = GetAudioReceiveStreamStats();
     EXPECT_EQ(info.ssrc(), stats.remote_ssrc);
     EXPECT_EQ(info.bytes_rcvd, stats.bytes_rcvd);
-    EXPECT_EQ(info.packets_rcvd, stats.packets_rcvd);
-    EXPECT_EQ(info.packets_lost, stats.packets_lost);
+    EXPECT_EQ(rtc::checked_cast<unsigned int>(info.packets_rcvd),
+              stats.packets_rcvd);
+    EXPECT_EQ(rtc::checked_cast<unsigned int>(info.packets_lost),
+              stats.packets_lost);
     EXPECT_EQ(info.fraction_lost, stats.fraction_lost);
     EXPECT_EQ(info.codec_name, stats.codec_name);
     EXPECT_EQ(info.codec_payload_type, stats.codec_payload_type);
-    EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum);
-    EXPECT_EQ(info.jitter_ms, stats.jitter_ms);
-    EXPECT_EQ(info.jitter_buffer_ms, stats.jitter_buffer_ms);
-    EXPECT_EQ(info.jitter_buffer_preferred_ms,
+    EXPECT_EQ(rtc::checked_cast<unsigned int>(info.ext_seqnum),
+              stats.ext_seqnum);
+    EXPECT_EQ(rtc::checked_cast<unsigned int>(info.jitter_ms), stats.jitter_ms);
+    EXPECT_EQ(rtc::checked_cast<unsigned int>(info.jitter_buffer_ms),
+              stats.jitter_buffer_ms);
+    EXPECT_EQ(rtc::checked_cast<unsigned int>(info.jitter_buffer_preferred_ms),
               stats.jitter_buffer_preferred_ms);
-    EXPECT_EQ(info.delay_estimate_ms, stats.delay_estimate_ms);
+    EXPECT_EQ(rtc::checked_cast<unsigned int>(info.delay_estimate_ms),
+              stats.delay_estimate_ms);
     EXPECT_EQ(info.audio_level, stats.audio_level);
     EXPECT_EQ(info.total_samples_received, stats.total_samples_received);
     EXPECT_EQ(info.concealed_samples, stats.concealed_samples);
@@ -882,7 +887,7 @@
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   const auto& dm = GetRecvStreamConfig(kSsrcX).decoder_map;
-  ASSERT_EQ(1, dm.count(106));
+  ASSERT_EQ(1u, dm.count(106));
   EXPECT_EQ(webrtc::SdpAudioFormat("isac", 16000, 1), dm.at(106));
 }
 
@@ -1038,7 +1043,7 @@
   EXPECT_TRUE(SetupChannel());
   webrtc::RtpParameters nonexistent_parameters =
       channel_->GetRtpSendParameters(kSsrcX);
-  EXPECT_EQ(0, nonexistent_parameters.encodings.size());
+  EXPECT_EQ(0u, nonexistent_parameters.encodings.size());
 
   nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
   EXPECT_FALSE(
@@ -1489,7 +1494,7 @@
   EXPECT_EQ(111, spec.payload_type);
   EXPECT_EQ(96000, spec.target_bitrate_bps);
   EXPECT_EQ("opus", spec.format.name);
-  EXPECT_EQ(2, spec.format.num_channels);
+  EXPECT_EQ(2u, spec.format.num_channels);
   EXPECT_EQ(48000, spec.format.clockrate_hz);
 }
 
@@ -1870,7 +1875,7 @@
   const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.payload_type);
   EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str());
-  EXPECT_EQ(1, send_codec_spec.format.num_channels);
+  EXPECT_EQ(1u, send_codec_spec.format.num_channels);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   SetSend(true);
   EXPECT_TRUE(channel_->CanInsertDtmf());
@@ -1896,7 +1901,7 @@
   const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.payload_type);
   EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str());
-  EXPECT_EQ(1, send_codec_spec.format.num_channels);
+  EXPECT_EQ(1u, send_codec_spec.format.num_channels);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   SetSend(true);
   EXPECT_TRUE(channel_->CanInsertDtmf());
@@ -1915,7 +1920,7 @@
   {
     const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
     EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str());
-    EXPECT_EQ(1, send_codec_spec.format.num_channels);
+    EXPECT_EQ(1u, send_codec_spec.format.num_channels);
     EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   }
   // Set PCMU(8K) and CN(16K). VAD should not be activated.
@@ -1932,7 +1937,7 @@
   {
     const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
     EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
-    EXPECT_EQ(1, send_codec_spec.format.num_channels);
+    EXPECT_EQ(1u, send_codec_spec.format.num_channels);
     EXPECT_EQ(13, send_codec_spec.cng_payload_type);
   }
   // Set ISAC(16K) and CN(8K). VAD should not be activated.
@@ -1962,7 +1967,7 @@
   const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.payload_type);
   EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str());
-  EXPECT_EQ(1, send_codec_spec.format.num_channels);
+  EXPECT_EQ(1u, send_codec_spec.format.num_channels);
   EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   SetSend(true);
   EXPECT_TRUE(channel_->CanInsertDtmf());
@@ -2124,7 +2129,7 @@
     const auto& send_codec_spec =
         *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
     EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str());
-    EXPECT_EQ(1, send_codec_spec.format.num_channels);
+    EXPECT_EQ(1u, send_codec_spec.format.num_channels);
     EXPECT_EQ(97, send_codec_spec.cng_payload_type);
   }
 
@@ -2200,7 +2205,7 @@
 
     // We have added one receive stream. We should see empty stats.
     EXPECT_EQ(info.receivers.size(), 1u);
-    EXPECT_EQ(info.receivers[0].ssrc(), 0);
+    EXPECT_EQ(info.receivers[0].ssrc(), 0u);
   }
 
   // Remove the kSsrcY stream. No receiver stats.
@@ -2423,7 +2428,7 @@
     VerifyVoiceSenderInfo(info.senders[0], false);
     // We have added one receive stream. We should see empty stats.
     EXPECT_EQ(info.receivers.size(), 1u);
-    EXPECT_EQ(info.receivers[0].ssrc(), 0);
+    EXPECT_EQ(info.receivers[0].ssrc(), 0u);
   }
 
   // Start sending - this affects some reported stats.
@@ -2543,11 +2548,11 @@
 // Test that receiving on an unsignaled stream works (a stream is created).
 TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignaled) {
   EXPECT_TRUE(SetupChannel());
-  EXPECT_EQ(0, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size());
 
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
 
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
   EXPECT_TRUE(GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame,
                                                      sizeof(kPcmuFrame)));
 }
@@ -2563,11 +2568,11 @@
   ASSERT_TRUE(channel_->AddRecvStream(unsignaled_stream));
   // The stream shouldn't have been created at this point because it doesn't
   // have any SSRCs.
-  EXPECT_EQ(0, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size());
 
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
 
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
   EXPECT_TRUE(
       GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame, sizeof(kPcmuFrame)));
   EXPECT_EQ(kSyncLabel, GetRecvStream(kSsrc1).GetConfig().sync_group);
@@ -2579,7 +2584,7 @@
 
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
 
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
   EXPECT_TRUE(
       GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame, sizeof(kPcmuFrame)));
   EXPECT_TRUE(GetRecvStream(kSsrc1).GetConfig().sync_group.empty());
@@ -2645,7 +2650,7 @@
   DeliverPacket(packet, sizeof(packet));
   EXPECT_TRUE(GetRecvStream(signaled_ssrc).VerifyLastPacket(
       packet, sizeof(packet)));
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
 
   // Note that the first unknown SSRC cannot be 0, because we only support
   // creating receive streams for SSRC!=0.
@@ -2654,7 +2659,7 @@
   DeliverPacket(packet, sizeof(packet));
   EXPECT_TRUE(GetRecvStream(unsignaled_ssrc).VerifyLastPacket(
       packet, sizeof(packet)));
-  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size());
 
   DeliverPacket(packet, sizeof(packet));
   EXPECT_EQ(2, GetRecvStream(unsignaled_ssrc).received_packets());
@@ -2662,7 +2667,7 @@
   rtc::SetBE32(&packet[8], signaled_ssrc);
   DeliverPacket(packet, sizeof(packet));
   EXPECT_EQ(2, GetRecvStream(signaled_ssrc).received_packets());
-  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size());
 }
 
 // Two tests to verify that adding a receive stream with the same SSRC as a
@@ -2673,17 +2678,17 @@
 
   // Spawn unsignaled stream with SSRC=1.
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
   EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame,
                                                 sizeof(kPcmuFrame)));
 
   // Verify that the underlying stream object in Call is not recreated when a
   // stream with SSRC=1 is added.
   const auto& streams = call_.GetAudioReceiveStreams();
-  EXPECT_EQ(1, streams.size());
+  EXPECT_EQ(1u, streams.size());
   int audio_receive_stream_id = streams.front()->id();
   EXPECT_TRUE(AddRecvStream(1));
-  EXPECT_EQ(1, streams.size());
+  EXPECT_EQ(1u, streams.size());
   EXPECT_EQ(audio_receive_stream_id, streams.front()->id());
 }
 
@@ -2692,20 +2697,20 @@
 
   // Spawn unsignaled stream with SSRC=1.
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
   EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame,
                                                 sizeof(kPcmuFrame)));
 
   // Verify that the underlying stream object in Call *is* recreated when a
   // stream with SSRC=1 is added, and which has changed stream parameters.
   const auto& streams = call_.GetAudioReceiveStreams();
-  EXPECT_EQ(1, streams.size());
+  EXPECT_EQ(1u, streams.size());
   int audio_receive_stream_id = streams.front()->id();
   cricket::StreamParams stream_params;
   stream_params.ssrcs.push_back(1);
   stream_params.set_stream_ids({"stream_id"});
   EXPECT_TRUE(channel_->AddRecvStream(stream_params));
-  EXPECT_EQ(1, streams.size());
+  EXPECT_EQ(1u, streams.size());
   EXPECT_NE(audio_receive_stream_id, streams.front()->id());
 }
 
@@ -2737,12 +2742,12 @@
   EXPECT_TRUE(AddRecvStream(1));
   EXPECT_TRUE(AddRecvStream(2));
 
-  EXPECT_EQ(1, call_.GetAudioSendStreams().size());
-  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioSendStreams().size());
+  EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size());
   delete channel_;
   channel_ = NULL;
-  EXPECT_EQ(0, call_.GetAudioSendStreams().size());
-  EXPECT_EQ(0, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(0u, call_.GetAudioSendStreams().size());
+  EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) {
@@ -2786,14 +2791,14 @@
   EXPECT_CALL(adm_,
               BuiltInNSIsAvailable()).Times(2).WillRepeatedly(Return(false));
 
-  EXPECT_EQ(50, GetRecvStreamConfig(kSsrcY).jitter_buffer_max_packets);
+  EXPECT_EQ(50u, GetRecvStreamConfig(kSsrcY).jitter_buffer_max_packets);
   EXPECT_FALSE(GetRecvStreamConfig(kSsrcY).jitter_buffer_fast_accelerate);
 
   // Nothing set in AudioOptions, so everything should be as default.
   send_parameters_.options = cricket::AudioOptions();
   SetSendParameters(send_parameters_);
   EXPECT_TRUE(IsHighPassFilterEnabled());
-  EXPECT_EQ(50, GetRecvStreamConfig(kSsrcY).jitter_buffer_max_packets);
+  EXPECT_EQ(50u, GetRecvStreamConfig(kSsrcY).jitter_buffer_max_packets);
   EXPECT_FALSE(GetRecvStreamConfig(kSsrcY).jitter_buffer_fast_accelerate);
 
   // Turn echo cancellation off
@@ -3095,7 +3100,7 @@
   sp.ssrcs[0] += 1;
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
-  ASSERT_EQ(2, call_.GetAudioReceiveStreams().size());
+  ASSERT_EQ(2u, call_.GetAudioReceiveStreams().size());
   EXPECT_EQ(kStreamId,
             call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
       << "SyncGroup should be set based on stream id";
@@ -3120,11 +3125,11 @@
         cricket::StreamParams::CreateLegacy(ssrc)));
   }
 
-  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size());
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
-    EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
+    EXPECT_EQ(0u, s->GetConfig().rtp.extensions.size());
   }
 
   // Set up receive extensions.
@@ -3132,7 +3137,7 @@
   cricket::AudioRecvParameters recv_parameters;
   recv_parameters.extensions = capabilities.header_extensions;
   channel_->SetRecvParameters(recv_parameters);
-  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size());
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
@@ -3152,7 +3157,7 @@
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
-    EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
+    EXPECT_EQ(0u, s->GetConfig().rtp.extensions.size());
   }
 }
 
@@ -3175,7 +3180,7 @@
   EXPECT_TRUE(media_channel->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kAudioSsrc)));
 
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
   const cricket::FakeAudioReceiveStream* s =
       call_.GetAudioReceiveStream(kAudioSsrc);
   EXPECT_EQ(0, s->received_packets());
@@ -3450,7 +3455,7 @@
       webrtc::Call::Create(webrtc::Call::Config(&event_log)));
 
   cricket::VoiceMediaChannel* channels[32];
-  int num_channels = 0;
+  size_t num_channels = 0;
   while (num_channels < arraysize(channels)) {
     cricket::VoiceMediaChannel* channel = engine.CreateChannel(
         call.get(), cricket::MediaConfig(), cricket::AudioOptions());
@@ -3459,7 +3464,7 @@
     channels[num_channels++] = channel;
   }
 
-  int expected = arraysize(channels);
+  size_t expected = arraysize(channels);
   EXPECT_EQ(expected, num_channels);
 
   while (num_channels > 0) {
@@ -3525,7 +3530,7 @@
                                     mock_decoder_factory, nullptr, apm);
   engine.Init();
   auto codecs = engine.recv_codecs();
-  EXPECT_EQ(11, codecs.size());
+  EXPECT_EQ(11u, codecs.size());
 
   // Rather than just ASSERTing that there are enough codecs, ensure that we can
   // check the actual values safely, to provide better test results.