Add an integration test frame encryption works with DependencyDescriptor

Bug: webrtc:10342
Change-Id: I3a18c1fbe222eada7a484f8f62a0b5bad76eb073
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168888
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30595}

test/call_test.cc

@@ -259,6 +259,8 @@ void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config,
                        &video_config->rtp.extensions);
   AddRtpExtensionByUri(RtpExtension::kGenericFrameDescriptorUri01,
                        &video_config->rtp.extensions);
+  AddRtpExtensionByUri(RtpExtension::kDependencyDescriptorUri,
+                       &video_config->rtp.extensions);
   if (video_encoder_configs_.empty()) {
     video_encoder_configs_.emplace_back();
     FillEncoderConfiguration(kVideoCodecGeneric, num_video_streams,

video/end_to_end_tests/frame_encryption_tests.cc

@@ -11,79 +11,81 @@
 #include "api/test/fake_frame_decryptor.h"
 #include "api/test/fake_frame_encryptor.h"
 #include "media/engine/internal_decoder_factory.h"
+#include "modules/rtp_rtcp/source/rtp_dependency_descriptor_extension.h"
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
 #include "test/call_test.h"
-#include "test/field_trial.h"
 #include "test/gtest.h"
 
 namespace webrtc {
 namespace {
+
+using FrameEncryptionEndToEndTest = test::CallTest;
+
 enum : int {  // The first valid value is 1.
   kGenericDescriptorExtensionId = 1,
 };
-}  // namespace
 
-class FrameEncryptionEndToEndTest : public test::CallTest {
+class DecryptedFrameObserver : public test::EndToEndTest,
+                               public rtc::VideoSinkInterface<VideoFrame> {
  public:
-  FrameEncryptionEndToEndTest() {
+  DecryptedFrameObserver()
-    RegisterRtpExtension(RtpExtension(RtpExtension::kGenericFrameDescriptorUri,
+      : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
-                                      kGenericDescriptorExtensionId));
+        encoder_factory_([] { return VP8Encoder::Create(); }) {}
-  }
 
  private:
-  // GenericDescriptor is required for FrameEncryption to work.
+  void ModifyVideoConfigs(
-  test::ScopedFieldTrials field_trials_{"WebRTC-GenericDescriptor/Enabled/"};
+      VideoSendStream::Config* send_config,
+      std::vector<VideoReceiveStream::Config>* receive_configs,
+      VideoEncoderConfig* encoder_config) override {
+    // Use VP8 instead of FAKE.
+    send_config->encoder_settings.encoder_factory = &encoder_factory_;
+    send_config->rtp.payload_name = "VP8";
+    send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+    send_config->frame_encryptor = new FakeFrameEncryptor();
+    send_config->crypto_options.sframe.require_frame_encryption = true;
+    encoder_config->codec_type = kVideoCodecVP8;
+    VideoReceiveStream::Decoder decoder =
+        test::CreateMatchingDecoder(*send_config);
+    decoder.decoder_factory = &decoder_factory_;
+    for (auto& recv_config : *receive_configs) {
+      recv_config.decoders.clear();
+      recv_config.decoders.push_back(decoder);
+      recv_config.renderer = this;
+      recv_config.frame_decryptor = new FakeFrameDecryptor();
+      recv_config.crypto_options.sframe.require_frame_encryption = true;
+    }
+  }
+
+  void OnFrame(const VideoFrame& video_frame) override {
+    observation_complete_.Set();
+  }
+
+  void PerformTest() override {
+    EXPECT_TRUE(Wait())
+        << "Timed out waiting for decrypted frames to be rendered.";
+  }
+
+  std::unique_ptr<VideoEncoder> encoder_;
+  test::FunctionVideoEncoderFactory encoder_factory_;
+  InternalDecoderFactory decoder_factory_;
 };
 
 // Validates that payloads cannot be sent without a frame encryptor and frame
 // decryptor attached.
-TEST_F(FrameEncryptionEndToEndTest, RequireFrameEncryptionEnforced) {
+TEST_F(FrameEncryptionEndToEndTest,
-  class DecryptedFrameObserver : public test::EndToEndTest,
+       WithGenericFrameDescriptorRequireFrameEncryptionEnforced) {
-                                 public rtc::VideoSinkInterface<VideoFrame> {
+  RegisterRtpExtension(RtpExtension(RtpExtension::kGenericFrameDescriptorUri00,
-   public:
+                                    kGenericDescriptorExtensionId));
-    DecryptedFrameObserver()
+  DecryptedFrameObserver test;
-        : EndToEndTest(kDefaultTimeoutMs),
-          encoder_factory_([]() { return VP8Encoder::Create(); }) {}
-
-   private:
-    void ModifyVideoConfigs(
-        VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
-        VideoEncoderConfig* encoder_config) override {
-      // Use VP8 instead of FAKE.
-      send_config->encoder_settings.encoder_factory = &encoder_factory_;
-      send_config->rtp.payload_name = "VP8";
-      send_config->rtp.payload_type = kVideoSendPayloadType;
-      send_config->frame_encryptor = new FakeFrameEncryptor();
-      send_config->crypto_options.sframe.require_frame_encryption = true;
-      encoder_config->codec_type = kVideoCodecVP8;
-      VideoReceiveStream::Decoder decoder =
-          test::CreateMatchingDecoder(*send_config);
-      decoder.decoder_factory = &decoder_factory_;
-      for (auto& recv_config : *receive_configs) {
-        recv_config.decoders.clear();
-        recv_config.decoders.push_back(decoder);
-        recv_config.renderer = this;
-        recv_config.frame_decryptor = new FakeFrameDecryptor();
-        recv_config.crypto_options.sframe.require_frame_encryption = true;
-      }
-    }
-
-    // Validate that rotation is preserved.
-    void OnFrame(const VideoFrame& video_frame) override {
-      observation_complete_.Set();
-    }
-
-    void PerformTest() override {
-      EXPECT_TRUE(Wait())
-          << "Timed out waiting for decrypted frames to be rendered.";
-    }
-
-    std::unique_ptr<VideoEncoder> encoder_;
-    test::FunctionVideoEncoderFactory encoder_factory_;
-    InternalDecoderFactory decoder_factory_;
-  } test;
-
   RunBaseTest(&test);
 }
+
+TEST_F(FrameEncryptionEndToEndTest,
+       WithDependencyDescriptorRequireFrameEncryptionEnforced) {
+  RegisterRtpExtension(RtpExtension(RtpExtension::kDependencyDescriptorUri,
+                                    kGenericDescriptorExtensionId));
+  DecryptedFrameObserver test;
+  RunBaseTest(&test);
+}
+}  // namespace
 }  // namespace webrtc