tree 29218ce14ebd34f0a87aadf20445db17205a9605
parent fa8f4eee40050e9875a4b8c38d99ea54a112c1ed
author Jonas Oreland <jonaso@webrtc.org> 1565963645 +0200
committer Commit Bot <commit-bot@chromium.org> 1566202521 +0000

Update constributing source before publishing frame

This patch is a follow up to https://webrtc-review.googlesource.com/c/src/+/143177.

That patch modified the updating of CSRCS until "publishing" the frame
to the renderer, however the update was added to just after
calling renderer->OnFrame(video_frame).

This patch reverses the calls of renderer->OnFrame(video_frame)
and source_tracker_.OnFrameDelivered(video_frame.packet_infos())
so that the CSRCS are available when the frame is available.

This fixes the the flakes described in webrtc:10827 that has a
test that checks the CSRCs directly after a frame is available.

Note: an optimal/correct solution would be to update the renderer
and the source tracker in the same critical section so that they
would be available at the same time.

Bug: webrtc:10827
Change-Id: Ibf6efa832d8f2f2bcce0a9b0b946188bb67d48b1
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/149171
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Chen Xing <chxg@google.com>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Jonas Oreland <jonaso@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28885}
