[webcodecs] Make sure callbacks aren't called after encoder.reset()

Bug: 1146170
Change-Id: Idd807b7f6e2618c8b4e1f161a2c66d74b4b40374
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2531901Reviewed-by: Dan Sanders <sandersd@chromium.org>
Commit-Queue: Eugene Zemtsov <eugene@chromium.org>
Cr-Commit-Position: refs/heads/master@{#826478}

third_party/blink/renderer/modules/webcodecs/video_encoder.cc

@@ -345,6 +345,7 @@ void VideoEncoder::configure(const VideoEncoderConfig* config,
   state_ = V8CodecState(V8CodecState::Enum::kConfigured);
 
   Request* request = MakeGarbageCollected<Request>();
+  request->reset_count = reset_count_;
   request->type = Request::Type::kConfigure;
   active_config_ = std::move(parsed_config);
   EnqueueRequest(request);
@@ -390,11 +391,12 @@ void VideoEncoder::encode(VideoFrame* frame,
   frame->destroy();
 
   Request* request = MakeGarbageCollected<Request>();
+  request->reset_count = reset_count_;
   request->type = Request::Type::kEncode;
   request->frame = internal_frame;
   request->encodeOpts = opts;
   ++requested_encodes_;
-  return EnqueueRequest(request);
+  EnqueueRequest(request);
 }
 
 void VideoEncoder::close(ExceptionState& exception_state) {
@@ -405,7 +407,7 @@ void VideoEncoder::close(ExceptionState& exception_state) {
 
   state_ = V8CodecState(V8CodecState::Enum::kClosed);
 
-  ClearRequests();
+  ResetInternal();
   media_encoder_.reset();
   output_callback_.Clear();
   error_callback_.Clear();
@@ -422,6 +424,7 @@ ScriptPromise VideoEncoder::flush(ExceptionState& exception_state) {
   Request* request = MakeGarbageCollected<Request>();
   request->resolver =
       MakeGarbageCollected<ScriptPromiseResolver>(script_state_);
+  request->reset_count = reset_count_;
   request->type = Request::Type::kFlush;
   EnqueueRequest(request);
   return request->resolver->Promise();
@@ -429,17 +432,17 @@ ScriptPromise VideoEncoder::flush(ExceptionState& exception_state) {
 
 void VideoEncoder::reset(ExceptionState& exception_state) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  // TODO: Not fully implemented yet
   if (ThrowIfCodecStateClosed(state_, "reset", exception_state))
     return;
 
-  ClearRequests();
+  ResetInternal();
 
   state_ = V8CodecState(V8CodecState::Enum::kUnconfigured);
 }
 
-void VideoEncoder::ClearRequests() {
+void VideoEncoder::ResetInternal() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  reset_count_++;
   while (!requests_.empty()) {
     Request* pending_req = requests_.TakeFirst();
     DCHECK(pending_req);
@@ -449,6 +452,7 @@ void VideoEncoder::ClearRequests() {
       pending_req->resolver.Release()->Reject(ex);
     }
   }
+  stall_request_processing_ = false;
 }
 
 void VideoEncoder::HandleError(DOMException* ex) {
@@ -457,7 +461,7 @@ void VideoEncoder::HandleError(DOMException* ex) {
 
   state_ = V8CodecState(V8CodecState::Enum::kClosed);
 
-  ClearRequests();
+  ResetInternal();
 
   // Errors are permanent. Shut everything down.
   error_callback_.Clear();
@@ -510,7 +514,7 @@ void VideoEncoder::ProcessEncode(Request* request) {
 
   auto done_callback = [](VideoEncoder* self, Request* req,
                           media::Status status) {
-    if (!self)
+    if (!self || self->reset_count_ != req->reset_count)
       return;
     DCHECK_CALLED_ON_VALID_SEQUENCE(self->sequence_checker_);
     if (!status.is_ok()) {
@@ -556,11 +560,11 @@ void VideoEncoder::ProcessConfigure(Request* request) {
   }
 
   auto output_cb = WTF::BindRepeating(&VideoEncoder::CallOutputCallback,
-                                      WrapWeakPersistent(this));
+                                      WrapWeakPersistent(this), reset_count_);
 
   auto done_callback = [](VideoEncoder* self, Request* req,
                           media::Status status) {
-    if (!self)
+    if (!self || self->reset_count_ != req->reset_count)
       return;
     DCHECK_CALLED_ON_VALID_SEQUENCE(self->sequence_checker_);
     DCHECK(self->active_config_);
@@ -589,9 +593,9 @@ void VideoEncoder::ProcessFlush(Request* request) {
 
   auto done_callback = [](VideoEncoder* self, Request* req,
                           media::Status status) {
-    DCHECK(req->resolver);
-    if (!self)
+    if (!self || self->reset_count_ != req->reset_count)
       return;
+    DCHECK(req->resolver);
     DCHECK_CALLED_ON_VALID_SEQUENCE(self->sequence_checker_);
     if (status.is_ok()) {
       req->resolver.Release()->Resolve();
@@ -612,10 +616,12 @@ void VideoEncoder::ProcessFlush(Request* request) {
 }
 
 void VideoEncoder::CallOutputCallback(
+    uint32_t reset_count,
     media::VideoEncoderOutput output,
     base::Optional<media::VideoEncoder::CodecDescription> codec_desc) {
   if (!script_state_->ContextIsValid() || !output_callback_ ||
-      state_.AsEnum() != V8CodecState::Enum::kConfigured)
+      state_.AsEnum() != V8CodecState::Enum::kConfigured ||
+      reset_count != reset_count_)
     return;
 
   EncodedVideoMetadata metadata;

third_party/blink/renderer/modules/webcodecs/video_encoder.h

@@ -90,12 +90,15 @@ class MODULES_EXPORT VideoEncoder final : public ScriptWrappable {
     void Trace(Visitor*) const;
 
     Type type;
+    // Current value of VideoEncoder.reset_count_ when request was created.
+    uint32_t reset_count = 0;
     Member<VideoFrame> frame;                            // used by kEncode
     Member<const VideoEncoderEncodeOptions> encodeOpts;  // used by kEncode
     Member<ScriptPromiseResolver> resolver;              // used by kFlush
   };
 
   void CallOutputCallback(
+      uint32_t reset_count,
       media::VideoEncoderOutput output,
       base::Optional<media::VideoEncoder::CodecDescription> codec_desc);
   void HandleError(DOMException* ex);
@@ -106,7 +109,7 @@ class MODULES_EXPORT VideoEncoder final : public ScriptWrappable {
   void ProcessConfigure(Request* request);
   void ProcessFlush(Request* request);
 
-  void ClearRequests();
+  void ResetInternal();
 
   std::unique_ptr<ParsedConfig> ParseConfig(const VideoEncoderConfig*,
                                             ExceptionState&);
@@ -124,6 +127,10 @@ class MODULES_EXPORT VideoEncoder final : public ScriptWrappable {
   Member<V8WebCodecsErrorCallback> error_callback_;
   HeapDeque<Member<Request>> requests_;
   int32_t requested_encodes_ = 0;
+  // How many times reset() was called on the encoder. It's used to decide
+  // when a callback needs to be dismissed because reset() was called between
+  // an operation and its callback.
+  uint32_t reset_count_ = 0;
 
   // Some kConfigure and kFlush requests can't be executed in parallel with
   // kEncode. This flag stops processing of new requests in the requests_ queue