insertable streams: add rtp sequence number to incoming audio metadata

spec change w3c/webrtc-encoded-transform#154

drive-by:
- fix idl of payloadType to be octet instead of short

BUG=chromium:1411703

Change-Id: Ic8dc8dcebb035a8f79823a8ca70e02ac1d6788cf
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3925401
Reviewed-by: Harald Alvestrand <[email protected]>
Commit-Queue: Philipp Hancke <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1100372}

Author: fippo

third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame.cc

@@ -18,17 +18,24 @@ RTCEncodedAudioFrame::RTCEncodedAudioFrame(
     std::unique_ptr<webrtc::TransformableFrameInterface> webrtc_frame)
     : delegate_(base::MakeRefCounted<RTCEncodedAudioFrameDelegate>(
           std::move(webrtc_frame),
-          Vector<uint32_t>())) {}
+          Vector<uint32_t>(),
+          absl::nullopt)) {}
 
 RTCEncodedAudioFrame::RTCEncodedAudioFrame(
     std::unique_ptr<webrtc::TransformableAudioFrameInterface>
         webrtc_audio_frame) {
   Vector<uint32_t> contributing_sources;
+  absl::optional<uint16_t> sequence_number;
   if (webrtc_audio_frame) {
     contributing_sources.assign(webrtc_audio_frame->GetContributingSources());
+    if (webrtc_audio_frame->GetDirection() ==
+        webrtc::TransformableFrameInterface::Direction::kReceiver) {
+      sequence_number = webrtc_audio_frame->GetHeader().sequenceNumber;
+    }
   }
   delegate_ = base::MakeRefCounted<RTCEncodedAudioFrameDelegate>(
-      std::move(webrtc_audio_frame), std::move(contributing_sources));
+      std::move(webrtc_audio_frame), std::move(contributing_sources),
+      sequence_number);
 }
 
 RTCEncodedAudioFrame::RTCEncodedAudioFrame(
@@ -56,6 +63,9 @@ RTCEncodedAudioFrameMetadata* RTCEncodedAudioFrame::getMetadata() const {
   if (delegate_->PayloadType()) {
     metadata->setPayloadType(*delegate_->PayloadType());
   }
+  if (delegate_->SequenceNumber()) {
+    metadata->setSequenceNumber(*delegate_->SequenceNumber());
+  }
   return metadata;
 }
 

third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame.h

@@ -7,6 +7,7 @@
 
 #include <stdint.h>
 
+#include "third_party/abseil-cpp/absl/types/optional.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
 #include "third_party/blink/renderer/platform/heap/member.h"
@@ -38,6 +39,7 @@ class MODULES_EXPORT RTCEncodedAudioFrame final : public ScriptWrappable {
   // rtc_encoded_audio_frame.idl implementation.
   // Returns the RTP Packet Timestamp for this frame.
   uint32_t timestamp() const;
+  absl::optional<uint16_t> sequenceNumber() const;
   DOMArrayBuffer* data() const;
   RTCEncodedAudioFrameMetadata* getMetadata() const;
   void setData(DOMArrayBuffer*);

third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame_delegate.cc

@@ -14,9 +14,11 @@ const void* RTCEncodedAudioFramesAttachment::kAttachmentKey;
 
 RTCEncodedAudioFrameDelegate::RTCEncodedAudioFrameDelegate(
     std::unique_ptr<webrtc::TransformableFrameInterface> webrtc_frame,
-    Vector<uint32_t> contributing_sources)
+    Vector<uint32_t> contributing_sources,
+    absl::optional<uint16_t> sequence_number)
     : webrtc_frame_(std::move(webrtc_frame)),
-      contributing_sources_(std::move(contributing_sources)) {}
+      contributing_sources_(std::move(contributing_sources)),
+      sequence_number_(sequence_number) {}
 
 uint32_t RTCEncodedAudioFrameDelegate::Timestamp() const {
   base::AutoLock lock(lock_);
@@ -61,6 +63,11 @@ absl::optional<uint8_t> RTCEncodedAudioFrameDelegate::PayloadType() const {
                        : absl::nullopt;
 }
 
+absl::optional<uint16_t> RTCEncodedAudioFrameDelegate::SequenceNumber() const {
+  base::AutoLock lock(lock_);
+  return sequence_number_;
+}
+
 Vector<uint32_t> RTCEncodedAudioFrameDelegate::ContributingSources() const {
   base::AutoLock lock(lock_);
   return contributing_sources_;

third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame_delegate.h

@@ -27,21 +27,24 @@ class RTCEncodedAudioFrameDelegate
  public:
   explicit RTCEncodedAudioFrameDelegate(
       std::unique_ptr<webrtc::TransformableFrameInterface> webrtc_frame,
-      Vector<uint32_t> contributing_sources);
+      Vector<uint32_t> contributing_sources,
+      absl::optional<uint16_t> sequence_number);
 
   uint32_t Timestamp() const;
   DOMArrayBuffer* CreateDataBuffer() const;
   void SetData(const DOMArrayBuffer* data);
   absl::optional<uint32_t> Ssrc() const;
   absl::optional<uint8_t> PayloadType() const;
+  absl::optional<uint16_t> SequenceNumber() const;
   Vector<uint32_t> ContributingSources() const;
   std::unique_ptr<webrtc::TransformableFrameInterface> PassWebRtcFrame();
 
  private:
   mutable base::Lock lock_;
   std::unique_ptr<webrtc::TransformableFrameInterface> webrtc_frame_
       GUARDED_BY(lock_);
-  Vector<uint32_t> contributing_sources_;
+  Vector<uint32_t> contributing_sources_ GUARDED_BY(lock_);
+  absl::optional<uint16_t> sequence_number_ GUARDED_BY(lock_);
 };
 
 class MODULES_EXPORT RTCEncodedAudioFramesAttachment

third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame_metadata.idl

@@ -8,5 +8,6 @@
 dictionary RTCEncodedAudioFrameMetadata {
     unsigned long synchronizationSource;
     sequence<unsigned long> contributingSources;
-    short payloadType;
+    octet payloadType;
+    unsigned short? sequenceNumber;
 };

third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_underlying_sink_test.cc

@@ -32,6 +32,7 @@
 using testing::_;
 using testing::NiceMock;
 using testing::Return;
+using testing::ReturnRef;
 
 namespace blink {
 
@@ -95,6 +96,8 @@ class RTCEncodedAudioUnderlyingSinkTest : public testing::Test {
           webrtc::TransformableFrameInterface::Direction::kSender) {
     auto mock_frame = std::make_unique<NiceMock<MockTransformableAudioFrame>>();
     ON_CALL(*mock_frame.get(), GetDirection).WillByDefault(Return(direction));
+    webrtc::RTPHeader header;
+    ON_CALL(*mock_frame.get(), GetHeader).WillByDefault(ReturnRef(header));
     std::unique_ptr<webrtc::TransformableAudioFrameInterface> audio_frame =
         base::WrapUnique(static_cast<webrtc::TransformableAudioFrameInterface*>(
             mock_frame.release()));

third_party/blink/renderer/modules/peerconnection/rtc_encoded_video_frame_metadata.idl

@@ -43,5 +43,5 @@ dictionary RTCEncodedVideoFrameMetadata {
     // RTP related metadata
     unsigned long synchronizationSource;
     sequence<unsigned long> contributingSources;
-    short payloadType;
+    octet payloadType;
 };

third_party/blink/web_tests/external/wpt/webrtc-encoded-transform/RTCPeerConnection-insertable-streams-audio.https.html

@@ -56,6 +56,7 @@
             // frames are not passed correctly between sender and receiver.
             assert_unreached("Incorrect frame received");
           }
+          assert_not_equals(result.value.getMetadata().sequenceNumber, undefined);
 
           if (numVerifiedFrames == numFramesToSend)
             resolve();