Fix race in video capture enable / disable.

In case we disable video capture and instantly enable video capture,
the PostTask already was invoked in setStateUpdated lambda, so
the later setStateUpdated(nullptr) didn't cancel the sent event.

After that we called instantly setOutgoingVideoState(Active),
and later after that the event was delivered,
calling setOutgoingVideoState(Inactive).

Now we use a separate explicit guard for the event, so that it
won't be delivered after setSTateUpdated(nullptr) call.

tgcalls/MediaManager.cpp

@@ -672,20 +672,27 @@ void MediaManager::setSendVideo(std::shared_ptr<VideoCaptureInterface> videoCapt
     const auto wasReceiving = computeIsReceivingVideo();
 
     if (_videoCapture) {
+		_videoCaptureGuard = nullptr;
 		GetVideoCaptureAssumingSameThread(_videoCapture.get())->setStateUpdated(nullptr);
     }
     _videoCapture = videoCapture;
 	if (_videoCapture) {
         _videoCapture->setPreferredAspectRatio(_preferredAspectRatio);
 
 		const auto thread = _thread;
-		const auto weak = std::weak_ptr<MediaManager>(shared_from_this());
         const auto object = GetVideoCaptureAssumingSameThread(_videoCapture.get());
         _isScreenCapture = object->isScreenCapture();
+        _videoCaptureGuard = std::make_shared<bool>(true);
+        const auto guard = std::weak_ptr{ _videoCaptureGuard };
 		object->setStateUpdated([=](VideoState state) {
 			thread->PostTask([=] {
-				if (const auto strong = weak.lock()) {
-					strong->setOutgoingVideoState(state);
+				// Checking this special guard instead of weak_ptr(this)
+				// ensures that we won't call setOutgoingVideoState after
+				// the _videoCapture was already changed and the old
+				// stateUpdated was already null-ed, but the event
+				// at that time was already posted.
+				if (guard.lock()) {
+					setOutgoingVideoState(state);
 				}
 			});
 		});

tgcalls/MediaManager.h

@@ -157,6 +157,7 @@ class MediaManager : public sigslot::has_slots<>, public std::enable_shared_from
 	std::unique_ptr<cricket::VideoMediaChannel> _videoChannel;
 	std::unique_ptr<webrtc::VideoBitrateAllocatorFactory> _videoBitrateAllocatorFactory;
 	std::shared_ptr<VideoCaptureInterface> _videoCapture;
+	std::shared_ptr<bool> _videoCaptureGuard;
     bool _isScreenCapture = false;
     std::shared_ptr<VideoSinkInterfaceProxyImpl> _incomingVideoSinkProxy;