BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

4 files changed, 94 insertions, 58 deletions

diff --git a/chromium/third_party/webrtc/call/test/mock_audio_send_stream.h b/chromium/third_party/webrtc/call/test/mock_audio_send_stream.h
index 489e826d0eb..4164dd550e1 100644
--- a/chromium/third_party/webrtc/call/test/mock_audio_send_stream.h
+++ b/chromium/third_party/webrtc/call/test/mock_audio_send_stream.h
@@ -21,23 +21,26 @@ namespace test {
 
 class MockAudioSendStream : public AudioSendStream {
  public:
-  MOCK_CONST_METHOD0(GetConfig, const webrtc::AudioSendStream::Config&());
-  MOCK_METHOD1(Reconfigure, void(const Config& config));
-  MOCK_METHOD0(Start, void());
-  MOCK_METHOD0(Stop, void());
+  MOCK_METHOD(const webrtc::AudioSendStream::Config&,
+              GetConfig,
+              (),
+              (const, override));
+  MOCK_METHOD(void, Reconfigure, (const Config& config), (override));
+  MOCK_METHOD(void, Start, (), (override));
+  MOCK_METHOD(void, Stop, (), (override));
   // GMock doesn't like move-only types, such as std::unique_ptr.
-  virtual void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) {
+  void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) override {
     SendAudioDataForMock(audio_frame.get());
   }
-  MOCK_METHOD1(SendAudioDataForMock, void(webrtc::AudioFrame* audio_frame));
-  MOCK_METHOD4(SendTelephoneEvent,
-               bool(int payload_type,
-                    int payload_frequency,
-                    int event,
-                    int duration_ms));
-  MOCK_METHOD1(SetMuted, void(bool muted));
-  MOCK_CONST_METHOD0(GetStats, Stats());
-  MOCK_CONST_METHOD1(GetStats, Stats(bool has_remote_tracks));
+  MOCK_METHOD(void, SendAudioDataForMock, (webrtc::AudioFrame*));
+  MOCK_METHOD(
+      bool,
+      SendTelephoneEvent,
+      (int payload_type, int payload_frequency, int event, int duration_ms),
+      (override));
+  MOCK_METHOD(void, SetMuted, (bool muted), (override));
+  MOCK_METHOD(Stats, GetStats, (), (const, override));
+  MOCK_METHOD(Stats, GetStats, (bool has_remote_tracks), (const, override));
 };
 }  // namespace test
 }  // namespace webrtc
diff --git a/chromium/third_party/webrtc/call/test/mock_bitrate_allocator.h b/chromium/third_party/webrtc/call/test/mock_bitrate_allocator.h
index f00ed79c59f..b08916fe4fc 100644
--- a/chromium/third_party/webrtc/call/test/mock_bitrate_allocator.h
+++ b/chromium/third_party/webrtc/call/test/mock_bitrate_allocator.h
@@ -18,10 +18,15 @@
 namespace webrtc {
 class MockBitrateAllocator : public BitrateAllocatorInterface {
  public:
-  MOCK_METHOD2(AddObserver,
-               void(BitrateAllocatorObserver*, MediaStreamAllocationConfig));
-  MOCK_METHOD1(RemoveObserver, void(BitrateAllocatorObserver*));
-  MOCK_CONST_METHOD1(GetStartBitrate, int(BitrateAllocatorObserver*));
+  MOCK_METHOD(void,
+              AddObserver,
+              (BitrateAllocatorObserver*, MediaStreamAllocationConfig),
+              (override));
+  MOCK_METHOD(void, RemoveObserver, (BitrateAllocatorObserver*), (override));
+  MOCK_METHOD(int,
+              GetStartBitrate,
+              (BitrateAllocatorObserver*),
+              (const, override));
 };
 }  // namespace webrtc
 #endif  // CALL_TEST_MOCK_BITRATE_ALLOCATOR_H_
diff --git a/chromium/third_party/webrtc/call/test/mock_rtp_packet_sink_interface.h b/chromium/third_party/webrtc/call/test/mock_rtp_packet_sink_interface.h
index adc804f941b..e6d14f05c5d 100644
--- a/chromium/third_party/webrtc/call/test/mock_rtp_packet_sink_interface.h
+++ b/chromium/third_party/webrtc/call/test/mock_rtp_packet_sink_interface.h
@@ -17,7 +17,7 @@ namespace webrtc {
 
 class MockRtpPacketSink : public RtpPacketSinkInterface {
  public:
-  MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived&));
+  MOCK_METHOD(void, OnRtpPacket, (const RtpPacketReceived&), (override));
 };
 
 }  // namespace webrtc
diff --git a/chromium/third_party/webrtc/call/test/mock_rtp_transport_controller_send.h b/chromium/third_party/webrtc/call/test/mock_rtp_transport_controller_send.h
index afc8400f73a..308c087a408 100644
--- a/chromium/third_party/webrtc/call/test/mock_rtp_transport_controller_send.h
+++ b/chromium/third_party/webrtc/call/test/mock_rtp_transport_controller_send.h
@@ -32,45 +32,73 @@ namespace webrtc {
 class MockRtpTransportControllerSend
     : public RtpTransportControllerSendInterface {
  public:
-  MOCK_METHOD10(
-      CreateRtpVideoSender,
-      RtpVideoSenderInterface*(std::map<uint32_t, RtpState>,
-                               const std::map<uint32_t, RtpPayloadState>&,
-                               const RtpConfig&,
-                               int rtcp_report_interval_ms,
-                               Transport*,
-                               const RtpSenderObservers&,
-                               RtcEventLog*,
-                               std::unique_ptr<FecController>,
-                               const RtpSenderFrameEncryptionConfig&,
-                               rtc::scoped_refptr<FrameTransformerInterface>));
-  MOCK_METHOD1(DestroyRtpVideoSender, void(RtpVideoSenderInterface*));
-  MOCK_METHOD0(GetWorkerQueue, rtc::TaskQueue*());
-  MOCK_METHOD0(packet_router, PacketRouter*());
-  MOCK_METHOD0(network_state_estimate_observer,
-               NetworkStateEstimateObserver*());
-  MOCK_METHOD0(transport_feedback_observer, TransportFeedbackObserver*());
-  MOCK_METHOD0(packet_sender, RtpPacketSender*());
-  MOCK_METHOD1(SetAllocatedSendBitrateLimits, void(BitrateAllocationLimits));
-  MOCK_METHOD1(SetPacingFactor, void(float));
-  MOCK_METHOD1(SetQueueTimeLimit, void(int));
-  MOCK_METHOD0(GetStreamFeedbackProvider, StreamFeedbackProvider*());
-  MOCK_METHOD1(RegisterTargetTransferRateObserver,
-               void(TargetTransferRateObserver*));
-  MOCK_METHOD2(OnNetworkRouteChanged,
-               void(const std::string&, const rtc::NetworkRoute&));
-  MOCK_METHOD1(OnNetworkAvailability, void(bool));
-  MOCK_METHOD0(GetBandwidthObserver, RtcpBandwidthObserver*());
-  MOCK_CONST_METHOD0(GetPacerQueuingDelayMs, int64_t());
-  MOCK_CONST_METHOD0(GetFirstPacketTime, absl::optional<Timestamp>());
-  MOCK_METHOD1(EnablePeriodicAlrProbing, void(bool));
-  MOCK_METHOD1(OnSentPacket, void(const rtc::SentPacket&));
-  MOCK_METHOD1(SetSdpBitrateParameters, void(const BitrateConstraints&));
-  MOCK_METHOD1(SetClientBitratePreferences, void(const BitrateSettings&));
-  MOCK_METHOD1(OnTransportOverheadChanged, void(size_t));
-  MOCK_METHOD1(AccountForAudioPacketsInPacedSender, void(bool));
-  MOCK_METHOD0(IncludeOverheadInPacedSender, void());
-  MOCK_METHOD1(OnReceivedPacket, void(const ReceivedPacket&));
+  MOCK_METHOD(RtpVideoSenderInterface*,
+              CreateRtpVideoSender,
+              ((std::map<uint32_t, RtpState>),
+               (const std::map<uint32_t, RtpPayloadState>&),
+               const RtpConfig&,
+               int rtcp_report_interval_ms,
+               Transport*,
+               const RtpSenderObservers&,
+               RtcEventLog*,
+               std::unique_ptr<FecController>,
+               const RtpSenderFrameEncryptionConfig&,
+               rtc::scoped_refptr<FrameTransformerInterface>),
+              (override));
+  MOCK_METHOD(void,
+              DestroyRtpVideoSender,
+              (RtpVideoSenderInterface*),
+              (override));
+  MOCK_METHOD(rtc::TaskQueue*, GetWorkerQueue, (), (override));
+  MOCK_METHOD(PacketRouter*, packet_router, (), (override));
+  MOCK_METHOD(NetworkStateEstimateObserver*,
+              network_state_estimate_observer,
+              (),
+              (override));
+  MOCK_METHOD(TransportFeedbackObserver*,
+              transport_feedback_observer,
+              (),
+              (override));
+  MOCK_METHOD(RtpPacketSender*, packet_sender, (), (override));
+  MOCK_METHOD(void,
+              SetAllocatedSendBitrateLimits,
+              (BitrateAllocationLimits),
+              (override));
+  MOCK_METHOD(void, SetPacingFactor, (float), (override));
+  MOCK_METHOD(void, SetQueueTimeLimit, (int), (override));
+  MOCK_METHOD(StreamFeedbackProvider*,
+              GetStreamFeedbackProvider,
+              (),
+              (override));
+  MOCK_METHOD(void,
+              RegisterTargetTransferRateObserver,
+              (TargetTransferRateObserver*),
+              (override));
+  MOCK_METHOD(void,
+              OnNetworkRouteChanged,
+              (const std::string&, const rtc::NetworkRoute&),
+              (override));
+  MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
+  MOCK_METHOD(RtcpBandwidthObserver*, GetBandwidthObserver, (), (override));
+  MOCK_METHOD(int64_t, GetPacerQueuingDelayMs, (), (const, override));
+  MOCK_METHOD(absl::optional<Timestamp>,
+              GetFirstPacketTime,
+              (),
+              (const, override));
+  MOCK_METHOD(void, EnablePeriodicAlrProbing, (bool), (override));
+  MOCK_METHOD(void, OnSentPacket, (const rtc::SentPacket&), (override));
+  MOCK_METHOD(void,
+              SetSdpBitrateParameters,
+              (const BitrateConstraints&),
+              (override));
+  MOCK_METHOD(void,
+              SetClientBitratePreferences,
+              (const BitrateSettings&),
+              (override));
+  MOCK_METHOD(void, OnTransportOverheadChanged, (size_t), (override));
+  MOCK_METHOD(void, AccountForAudioPacketsInPacedSender, (bool), (override));
+  MOCK_METHOD(void, IncludeOverheadInPacedSender, (), (override));
+  MOCK_METHOD(void, OnReceivedPacket, (const ReceivedPacket&), (override));
 };
 }  // namespace webrtc
 #endif  // CALL_TEST_MOCK_RTP_TRANSPORT_CONTROLLER_SEND_H_