Implementation of WebCodecs VideoDecoder.

This initial implementation is missing some key functionality (flush and
reset), but does implement backpressure correctly. It should run with
any media::VideoDecoder that does not depend on the media thread (eg.
FFmpegVideoDecoder).

The intention is that a new media::VideoDecoder (WebCodecVideoDecoder)
will be added in //media/blink, and it will be responsible for thread
hopping, decoder selection, and decoder fallback. That code is not yet
compiling.

Bug: 897297
Change-Id: Iaaba7868f8d31ab1011981dcbbdb06db0e6953d4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1979510
Commit-Queue: Dan Sanders <sandersd@chromium.org>
Reviewed-by: Mounir Lamouri <mlamouri@chromium.org>
Reviewed-by: Chrome Cunningham <chcunningham@chromium.org>
Cr-Commit-Position: refs/heads/master@{#738829}

third_party/blink/renderer/modules/webcodecs/DEPS

 include_rules = [
     "+base/run_loop.h",
+    "+media/base/media_util.h",
+    "+media/base/video_decoder.h",
     "+media/base/video_frame.h",
     "+ui/gfx/geometry/rect.h",
     "+ui/gfx/geometry/size.h",

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

@@ -5,7 +5,13 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_WEBCODECS_VIDEO_DECODER_H_
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_WEBCODECS_VIDEO_DECODER_H_
 
+#include <memory>
+
+#include "base/memory/weak_ptr.h"
+#include "base/sequence_checker.h"
+#include "media/base/video_decoder.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
+#include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
 
@@ -16,25 +22,73 @@ class ScriptState;
 class ReadableStream;
 class VideoDecoderInitParameters;
 class WritableStream;
+class Visitor;
 
 class MODULES_EXPORT VideoDecoder final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static VideoDecoder* Create();
-  VideoDecoder();
-  ScriptPromise Initialize(ScriptState*,
-                           const VideoDecoderInitParameters*,
-                           ExceptionState&);
-  ScriptPromise Flush(ScriptState*, ExceptionState&);
-  void Close();
+  static VideoDecoder* Create(ScriptState*, ExceptionState&);
+  VideoDecoder(ScriptState*, ExceptionState&);
+  ~VideoDecoder() override;
 
   // video_decoder.idl implementation.
   ReadableStream* readable() const;
   WritableStream* writable() const;
+  ScriptPromise initialize(const VideoDecoderInitParameters*, ExceptionState&);
 
   // GarbageCollected override.
   void Trace(Visitor*) override;
+
+ private:
+  SEQUENCE_CHECKER(sequence_checker_);
+
+  // Helper classes that manage the input and output streams.
+  class WritableSink;
+  class ReadableSource;
+
+  // Creates a new |write_resolver_| and returns a promise from it.
+  ScriptPromise CreateWritePromise();
+
+  // Resolves |write_resolver_| if the current state can accept a write.
+  void MaybeAcceptWrite();
+
+  // Rejects promises and shuts down streams.
+  void HandleError();
+
+  // Called by |decoder_|.
+  void OnInitializeDone(bool success);
+  void OnDecodeDone(media::DecodeStatus);
+  void OnOutput(scoped_refptr<media::VideoFrame>);
+
+  // Called by WritableSink.
+  ScriptPromise Start(ExceptionState&);
+  ScriptPromise Write(ScriptValue chunk, ExceptionState&);
+  ScriptPromise Close(ExceptionState&);
+  ScriptPromise Abort(ExceptionState&);
+
+  // Called by ReadableSource.
+  ScriptPromise Pull();
+  ScriptPromise Cancel();
+
+  Member<ScriptState> script_state_;
+  Member<WritableStream> writable_;
+  Member<ReadableStream> readable_;
+  Member<ReadableSource> readable_source_;
+
+  // Signals completion of initialize().
+  Member<ScriptPromiseResolver> initialize_resolver_;
+
+  // Signals ability to accept an input chunk.
+  Member<ScriptPromiseResolver> write_resolver_;
+
+  std::unique_ptr<media::VideoDecoder> decoder_;
+  bool has_error_ = false;
+  bool initialized_ = false;
+  int pending_decodes_ = 0;
+
+  base::WeakPtr<VideoDecoder> weak_this_;
+  base::WeakPtrFactory<VideoDecoder> weak_factory_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/webcodecs/video_decoder.idl

@@ -5,11 +5,9 @@
 [
     RuntimeEnabled=WebCodecs
 ] interface VideoDecoder {
-    constructor();
-    [CallWith=ScriptState, RaisesException] Promise<void> Initialize(VideoDecoderInitParameters params);
-    [CallWith=ScriptState, RaisesException] Promise<void> Flush();
-    void Close();
+    [CallWith=ScriptState, RaisesException] constructor();
+    [RaisesException] Promise<void> initialize(VideoDecoderInitParameters params);
 
-    readonly attribute WritableStream writable;  // of EncodedVideoFrame
+    readonly attribute WritableStream writable;  // of EncodedVideoChunk
     readonly attribute ReadableStream readable;  // of VideoFrame
 };

third_party/blink/web_tests/webexposed/global-interface-listing-expected.txt

@@ -8667,10 +8667,8 @@ interface VideoDecoder
     attribute @@toStringTag
     getter readable
     getter writable
-    method Close
-    method Flush
-    method Initialize
     method constructor
+    method initialize
 interface VideoFrame
     attribute @@toStringTag
     getter coded_height