Delete generic frame descriptor v1 trait and enum value

Bug: webrtc:11358
Change-Id: I272a45881f8ef9963b502c6d17edc97e7d9fbc8e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/173582
Reviewed-by: Markus Handell <handellm@webrtc.org>
Reviewed-by: Sam Zackrisson <saza@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31089}

modules/rtp_rtcp/include/rtp_rtcp_defines.h

@@ -70,7 +70,6 @@ enum RTPExtensionType : int {
   kRtpExtensionMid,
   kRtpExtensionGenericFrameDescriptor00,
   kRtpExtensionGenericFrameDescriptor = kRtpExtensionGenericFrameDescriptor00,
-  kRtpExtensionGenericFrameDescriptor01,
   kRtpExtensionGenericFrameDescriptor02,
   kRtpExtensionColorSpace,
   kRtpExtensionNumberOfExtensions  // Must be the last entity in the enum.

modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h

@@ -38,15 +38,6 @@ class RtpGenericFrameDescriptor {
   bool LastPacketInSubFrame() const { return end_of_subframe_; }
   void SetLastPacketInSubFrame(bool last) { end_of_subframe_ = last; }
 
-  // Denotes whether the frame is discardable. That is, whether skipping it
-  // would have no effect on the decodability of subsequent frames.
-  // An absl::optional is used because version 0 of the extension did not
-  // support this flag. (The optional aspect is relevant only when parsing.)
-  // TODO(bugs.webrtc.org/10243): Make this into a plain bool when v00 of
-  // the extension is deprecated.
-  absl::optional<bool> Discardable() const { return discardable_; }
-  void SetDiscardable(bool discardable) { discardable_ = discardable; }
-
   // Properties below undefined if !FirstPacketInSubFrame()
   // Valid range for temporal layer: [0, 7]
   int TemporalLayer() const;
@@ -74,8 +65,6 @@ class RtpGenericFrameDescriptor {
   bool beginning_of_subframe_ = false;
   bool end_of_subframe_ = false;
 
-  absl::optional<bool> discardable_;
-
   uint16_t frame_id_ = 0;
   uint8_t spatial_layers_ = 1;
   uint8_t temporal_layer_ = 0;

modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.cc

@@ -20,18 +20,16 @@ constexpr uint8_t kFlagEndOfSubframe = 0x40;
 
 // In version 00, the flags F and L in the first byte correspond to
 // kFlagFirstSubframeV00 and kFlagLastSubframeV00. In practice, they were
-// always set to |true|. In version 01, these flags are deprecated, and we use
+// always set to |true|.
-// one of their bits for the discardability flag.
 constexpr uint8_t kFlagFirstSubframeV00 = 0x20;
 constexpr uint8_t kFlagLastSubframeV00 = 0x10;
-constexpr uint8_t kFlagDiscardableV01 = 0x10;
 
 constexpr uint8_t kFlagDependencies = 0x08;
 constexpr uint8_t kMaskTemporalLayer = 0x07;
 
 constexpr uint8_t kFlagMoreDependencies = 0x01;
 constexpr uint8_t kFlageXtendedOffset = 0x02;
-
+}  // namespace
 //       0 1 2 3 4 5 6 7
 //      +-+-+-+-+-+-+-+-+
 //      |B|E|F|L|D|  T  |
@@ -58,9 +56,10 @@ constexpr uint8_t kFlageXtendedOffset = 0x02;
 //      +---------------+
 //      |      ...      |
 //      +-+-+-+-+-+-+-+-+
+constexpr RTPExtensionType RtpGenericFrameDescriptorExtension00::kId;
+constexpr char RtpGenericFrameDescriptorExtension00::kUri[];
 
-bool RtpGenericFrameDescriptorExtensionParse(
+bool RtpGenericFrameDescriptorExtension00::Parse(
-    size_t version,
     rtc::ArrayView<const uint8_t> data,
     RtpGenericFrameDescriptor* descriptor) {
   if (data.empty()) {
@@ -71,10 +70,6 @@ bool RtpGenericFrameDescriptorExtensionParse(
   descriptor->SetFirstPacketInSubFrame(begins_subframe);
   descriptor->SetLastPacketInSubFrame((data[0] & kFlagEndOfSubframe) != 0);
 
-  if (version >= 1) {
-    descriptor->SetDiscardable((data[0] & kFlagDiscardableV01) != 0);
-  }
-
   // Parse Subframe details provided in 1st packet of subframe.
   if (!begins_subframe) {
     return data.size() == 1;
@@ -115,7 +110,7 @@ bool RtpGenericFrameDescriptorExtensionParse(
   return true;
 }
 
-size_t RtpGenericFrameDescriptorExtensionValueSize(
+size_t RtpGenericFrameDescriptorExtension00::ValueSize(
     const RtpGenericFrameDescriptor& descriptor) {
   if (!descriptor.FirstPacketInSubFrame())
     return 1;
@@ -132,23 +127,15 @@ size_t RtpGenericFrameDescriptorExtensionValueSize(
   return size;
 }
 
-bool RtpGenericFrameDescriptorExtensionWrite(
+bool RtpGenericFrameDescriptorExtension00::Write(
-    size_t version,
     rtc::ArrayView<uint8_t> data,
     const RtpGenericFrameDescriptor& descriptor) {
-  RTC_CHECK_EQ(data.size(),
+  RTC_CHECK_EQ(data.size(), ValueSize(descriptor));
-
-               RtpGenericFrameDescriptorExtensionValueSize(descriptor));
   uint8_t base_header =
       (descriptor.FirstPacketInSubFrame() ? kFlagBeginOfSubframe : 0) |
       (descriptor.LastPacketInSubFrame() ? kFlagEndOfSubframe : 0);
-  if (version == 0) {
   base_header |= kFlagFirstSubframeV00;
   base_header |= kFlagLastSubframeV00;
-  } else if (version >= 1) {
-    const absl::optional<bool> discardable = descriptor.Discardable();
-    base_header |= (discardable.value_or(false) ? kFlagDiscardableV01 : 0);
-  }
 
   if (!descriptor.FirstPacketInSubFrame()) {
     data[0] = base_header;
@@ -184,48 +171,4 @@ bool RtpGenericFrameDescriptorExtensionWrite(
   return true;
 }
 
-}  // namespace
-
-constexpr RTPExtensionType RtpGenericFrameDescriptorExtension00::kId;
-constexpr char RtpGenericFrameDescriptorExtension00::kUri[];
-
-bool RtpGenericFrameDescriptorExtension00::Parse(
-    rtc::ArrayView<const uint8_t> data,
-    RtpGenericFrameDescriptor* descriptor) {
-  return RtpGenericFrameDescriptorExtensionParse(0, data, descriptor);
-}
-
-size_t RtpGenericFrameDescriptorExtension00::ValueSize(
-    const RtpGenericFrameDescriptor& descriptor) {
-  // No difference between existing versions.
-  return RtpGenericFrameDescriptorExtensionValueSize(descriptor);
-}
-
-bool RtpGenericFrameDescriptorExtension00::Write(
-    rtc::ArrayView<uint8_t> data,
-    const RtpGenericFrameDescriptor& descriptor) {
-  return RtpGenericFrameDescriptorExtensionWrite(0, data, descriptor);
-}
-
-constexpr RTPExtensionType RtpGenericFrameDescriptorExtension01::kId;
-constexpr char RtpGenericFrameDescriptorExtension01::kUri[];
-
-bool RtpGenericFrameDescriptorExtension01::Parse(
-    rtc::ArrayView<const uint8_t> data,
-    RtpGenericFrameDescriptor* descriptor) {
-  return RtpGenericFrameDescriptorExtensionParse(1, data, descriptor);
-}
-
-size_t RtpGenericFrameDescriptorExtension01::ValueSize(
-    const RtpGenericFrameDescriptor& descriptor) {
-  // No difference between existing versions.
-  return RtpGenericFrameDescriptorExtensionValueSize(descriptor);
-}
-
-bool RtpGenericFrameDescriptorExtension01::Write(
-    rtc::ArrayView<uint8_t> data,
-    const RtpGenericFrameDescriptor& descriptor) {
-  return RtpGenericFrameDescriptorExtensionWrite(1, data, descriptor);
-}
-
 }  // namespace webrtc

modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h

@@ -35,22 +35,6 @@ class RtpGenericFrameDescriptorExtension00 {
                     const RtpGenericFrameDescriptor& descriptor);
 };
 
-class RtpGenericFrameDescriptorExtension01 {
- public:
-  using value_type = RtpGenericFrameDescriptor;
-  static constexpr RTPExtensionType kId = kRtpExtensionGenericFrameDescriptor01;
-  static constexpr char kUri[] =
-      "http://www.webrtc.org/experiments/rtp-hdrext/"
-      "generic-frame-descriptor-01";
-  static constexpr int kMaxSizeBytes = 16;
-
-  static bool Parse(rtc::ArrayView<const uint8_t> data,
-                    RtpGenericFrameDescriptor* descriptor);
-  static size_t ValueSize(const RtpGenericFrameDescriptor& descriptor);
-  static bool Write(rtc::ArrayView<uint8_t> data,
-                    const RtpGenericFrameDescriptor& descriptor);
-};
-
 }  // namespace webrtc
 
 #endif  // MODULES_RTP_RTCP_SOURCE_RTP_GENERIC_FRAME_DESCRIPTOR_EXTENSION_H_

modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension_unittest.cc

@@ -23,87 +23,27 @@ constexpr uint8_t kDeprecatedFlags = 0x30;
 
 // TODO(danilchap): Add fuzzer to test for various invalid inputs.
 
-class RtpGenericFrameDescriptorExtensionTest
+TEST(RtpGenericFrameDescriptorExtensionTest,
-    : public ::testing::Test,
-      public ::testing::WithParamInterface<int> {
- public:
-  RtpGenericFrameDescriptorExtensionTest() : version_(GetParam()) {}
-
-  bool Parse(rtc::ArrayView<const uint8_t> data,
-             RtpGenericFrameDescriptor* descriptor) const {
-    switch (version_) {
-      case 0:
-        return RtpGenericFrameDescriptorExtension00::Parse(data, descriptor);
-      case 1:
-        return RtpGenericFrameDescriptorExtension01::Parse(data, descriptor);
-    }
-    RTC_NOTREACHED();
-    return false;
-  }
-
-  size_t ValueSize(const RtpGenericFrameDescriptor& descriptor) const {
-    switch (version_) {
-      case 0:
-        return RtpGenericFrameDescriptorExtension00::ValueSize(descriptor);
-      case 1:
-        return RtpGenericFrameDescriptorExtension01::ValueSize(descriptor);
-    }
-    RTC_NOTREACHED();
-    return 0;
-  }
-
-  bool Write(rtc::ArrayView<uint8_t> data,
-             const RtpGenericFrameDescriptor& descriptor) const {
-    switch (version_) {
-      case 0:
-        return RtpGenericFrameDescriptorExtension00::Write(data, descriptor);
-      case 1:
-        return RtpGenericFrameDescriptorExtension01::Write(data, descriptor);
-    }
-    RTC_NOTREACHED();
-    return false;
-  }
-
- protected:
-  const int version_;
-};
-
-INSTANTIATE_TEST_SUITE_P(All,
-                         RtpGenericFrameDescriptorExtensionTest,
-                         ::testing::Values(0, 1));
-
-TEST_P(RtpGenericFrameDescriptorExtensionTest,
      ParseFirstPacketOfIndependenSubFrame) {
   const int kTemporalLayer = 5;
   constexpr uint8_t kRaw[] = {0x80 | kTemporalLayer, 0x49, 0x12, 0x34};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
 
   EXPECT_TRUE(descriptor.FirstPacketInSubFrame());
   EXPECT_FALSE(descriptor.LastPacketInSubFrame());
 
-  const absl::optional<bool> discardable = descriptor.Discardable();
-  if (version_ == 0) {
-    ASSERT_FALSE(discardable.has_value());
-  } else {
-    ASSERT_TRUE(discardable.has_value());
-    EXPECT_FALSE(discardable.value());
-  }
-
   EXPECT_THAT(descriptor.FrameDependenciesDiffs(), IsEmpty());
   EXPECT_EQ(descriptor.TemporalLayer(), kTemporalLayer);
   EXPECT_EQ(descriptor.SpatialLayersBitmask(), 0x49);
   EXPECT_EQ(descriptor.FrameId(), 0x3412);
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest,
+TEST(RtpGenericFrameDescriptorExtensionTest,
      WriteFirstPacketOfIndependenSubFrame) {
   const int kTemporalLayer = 5;
-  uint8_t kRaw[] = {0x80 | kTemporalLayer, 0x49, 0x12, 0x34};
+  uint8_t kRaw[] = {0x80 | kTemporalLayer | kDeprecatedFlags, 0x49, 0x12, 0x34};
-  if (version_ == 0) {
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
 
   descriptor.SetFirstPacketInSubFrame(true);
@@ -111,263 +51,215 @@ TEST_P(RtpGenericFrameDescriptorExtensionTest,
   descriptor.SetSpatialLayersBitmask(0x49);
   descriptor.SetFrameId(0x3412);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
 
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseLastPacketOfSubFrame) {
+TEST(RtpGenericFrameDescriptorExtensionTest, ParseLastPacketOfSubFrame) {
   constexpr uint8_t kRaw[] = {0x40};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
 
   EXPECT_FALSE(descriptor.FirstPacketInSubFrame());
-
-  const absl::optional<bool> discardable = descriptor.Discardable();
-  if (version_ == 0) {
-    ASSERT_FALSE(discardable.has_value());
-  } else {
-    ASSERT_TRUE(discardable.has_value());
-    EXPECT_FALSE(discardable.value());
-  }
-
   EXPECT_TRUE(descriptor.LastPacketInSubFrame());
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteLastPacketOfSubFrame) {
+TEST(RtpGenericFrameDescriptorExtensionTest, WriteLastPacketOfSubFrame) {
-  uint8_t kRaw[] = {0x40};
+  uint8_t kRaw[] = {0x40 | kDeprecatedFlags};
-  if (version_ == 0) {
-    kRaw[0] |= kDeprecatedFlags;
-  }
 
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetLastPacketInSubFrame(true);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseDiscardable) {
+TEST(RtpGenericFrameDescriptorExtensionTest, ParseMinShortFrameDependencies) {
-  if (version_ == 0) {
-    return;
-  }
-
-  constexpr uint8_t kRaw[] = {0x10};
-  RtpGenericFrameDescriptor descriptor;
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
-  const absl::optional<bool> discardable = descriptor.Discardable();
-  ASSERT_TRUE(discardable.has_value());
-  EXPECT_TRUE(discardable.value());
-}
-
-TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteDiscardable) {
-  if (version_ == 0) {
-    return;
-  }
-
-  constexpr uint8_t kRaw[] = {0x10};
-  RtpGenericFrameDescriptor descriptor;
-  descriptor.SetDiscardable(true);
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
-  uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
-  EXPECT_THAT(buffer, ElementsAreArray(kRaw));
-}
-
-TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMinShortFrameDependencies) {
   constexpr uint16_t kDiff = 1;
   constexpr uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x04};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
   ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
   EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMinShortFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, WriteMinShortFrameDependencies) {
   constexpr uint16_t kDiff = 1;
-  uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x04};
+  uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x04};
-  if (version_ == 0) {
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetFirstPacketInSubFrame(true);
   descriptor.AddFrameDependencyDiff(kDiff);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMaxShortFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, ParseMaxShortFrameDependencies) {
   constexpr uint16_t kDiff = 0x3f;
   constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0xfc};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
   ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
   EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMaxShortFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, WriteMaxShortFrameDependencies) {
   constexpr uint16_t kDiff = 0x3f;
-  uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0xfc};
+  uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0xfc};
-  if (version_ == 0) {
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetFirstPacketInSubFrame(true);
   descriptor.AddFrameDependencyDiff(kDiff);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMinLongFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, ParseMinLongFrameDependencies) {
   constexpr uint16_t kDiff = 0x40;
   constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0x02, 0x01};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
   ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
   EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMinLongFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, WriteMinLongFrameDependencies) {
   constexpr uint16_t kDiff = 0x40;
-  uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x02, 0x01};
+  uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x02, 0x01};
-  if (version_ == 0) {
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetFirstPacketInSubFrame(true);
   descriptor.AddFrameDependencyDiff(kDiff);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest,
+TEST(RtpGenericFrameDescriptorExtensionTest,
      ParseLongFrameDependenciesAsBigEndian) {
   constexpr uint16_t kDiff = 0x7654 >> 2;
   constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0x54 | 0x02, 0x76};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
   ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
   EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest,
+TEST(RtpGenericFrameDescriptorExtensionTest,
      WriteLongFrameDependenciesAsBigEndian) {
   constexpr uint16_t kDiff = 0x7654 >> 2;
-  uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x54 | 0x02, 0x76};
+  uint8_t kRaw[] = {
-  if (version_ == 0) {
+      0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x54 | 0x02, 0x76};
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetFirstPacketInSubFrame(true);
   descriptor.AddFrameDependencyDiff(kDiff);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMaxLongFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, ParseMaxLongFrameDependencies) {
   constexpr uint16_t kDiff = 0x3fff;
   constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0xfe, 0xff};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
   ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
   EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMaxLongFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, WriteMaxLongFrameDependencies) {
   constexpr uint16_t kDiff = 0x3fff;
-  uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0xfe, 0xff};
+  uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0xfe, 0xff};
-  if (version_ == 0) {
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetFirstPacketInSubFrame(true);
   descriptor.AddFrameDependencyDiff(kDiff);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseTwoFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, ParseTwoFrameDependencies) {
   constexpr uint16_t kDiff1 = 9;
   constexpr uint16_t kDiff2 = 15;
   constexpr uint8_t kRaw[] = {
       0xb8, 0x01, 0x00, 0x00, (kDiff1 << 2) | 0x01, kDiff2 << 2};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
   ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
   EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff1, kDiff2));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteTwoFrameDependencies) {
+TEST(RtpGenericFrameDescriptorExtensionTest, WriteTwoFrameDependencies) {
   constexpr uint16_t kDiff1 = 9;
   constexpr uint16_t kDiff2 = 15;
-  uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, (kDiff1 << 2) | 0x01, kDiff2 << 2};
+  uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01,       0x00, 0x00,
-  if (version_ == 0) {
+                    (kDiff1 << 2) | 0x01,    kDiff2 << 2};
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetFirstPacketInSubFrame(true);
   descriptor.AddFrameDependencyDiff(kDiff1);
   descriptor.AddFrameDependencyDiff(kDiff2);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest,
+TEST(RtpGenericFrameDescriptorExtensionTest,
      ParseResolutionOnIndependentFrame) {
   constexpr int kWidth = 0x2468;
   constexpr int kHeight = 0x6543;
   constexpr uint8_t kRaw[] = {0xb0, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
   RtpGenericFrameDescriptor descriptor;
 
-  ASSERT_TRUE(Parse(kRaw, &descriptor));
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
   EXPECT_EQ(descriptor.Width(), kWidth);
   EXPECT_EQ(descriptor.Height(), kHeight);
 }
 
-TEST_P(RtpGenericFrameDescriptorExtensionTest,
+TEST(RtpGenericFrameDescriptorExtensionTest,
      WriteResolutionOnIndependentFrame) {
   constexpr int kWidth = 0x2468;
   constexpr int kHeight = 0x6543;
-  uint8_t kRaw[] = {0x80, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
+  uint8_t kRaw[] = {
-  if (version_ == 0) {
+      0x80 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
-    kRaw[0] |= kDeprecatedFlags;
-  }
   RtpGenericFrameDescriptor descriptor;
   descriptor.SetFirstPacketInSubFrame(true);
   descriptor.SetResolution(kWidth, kHeight);
 
-  ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
+            sizeof(kRaw));
   uint8_t buffer[sizeof(kRaw)];
-  EXPECT_TRUE(Write(buffer, descriptor));
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 }  // namespace

modules/rtp_rtcp/source/rtp_header_extension_map.cc

@@ -46,7 +46,6 @@ constexpr ExtensionInfo kExtensions[] = {
     CreateExtensionInfo<RepairedRtpStreamId>(),
     CreateExtensionInfo<RtpMid>(),
     CreateExtensionInfo<RtpGenericFrameDescriptorExtension00>(),
-    CreateExtensionInfo<RtpGenericFrameDescriptorExtension01>(),
     CreateExtensionInfo<RtpDependencyDescriptorExtension>(),
     CreateExtensionInfo<ColorSpaceExtension>(),
     CreateExtensionInfo<InbandComfortNoiseExtension>(),

modules/rtp_rtcp/source/rtp_packet.cc

@@ -190,7 +190,6 @@ void RtpPacket::ZeroMutableExtensions() {
       case RTPExtensionType::kRtpExtensionColorSpace:
       case RTPExtensionType::kRtpExtensionFrameMarking:
       case RTPExtensionType::kRtpExtensionGenericFrameDescriptor00:
-      case RTPExtensionType::kRtpExtensionGenericFrameDescriptor01:
       case RTPExtensionType::kRtpExtensionGenericFrameDescriptor02:
       case RTPExtensionType::kRtpExtensionMid:
       case RTPExtensionType::kRtpExtensionNumberOfExtensions:

modules/rtp_rtcp/source/rtp_sender.cc

@@ -82,8 +82,6 @@ constexpr RtpExtensionSize kVideoExtensionSizes[] = {
     CreateMaxExtensionSize<RtpMid>(),
     {RtpGenericFrameDescriptorExtension00::kId,
      RtpGenericFrameDescriptorExtension00::kMaxSizeBytes},
-    {RtpGenericFrameDescriptorExtension01::kId,
-     RtpGenericFrameDescriptorExtension01::kMaxSizeBytes},
 };
 
 bool HasBweExtension(const RtpHeaderExtensionMap& extensions_map) {

modules/rtp_rtcp/source/rtp_sender_unittest.cc

@@ -47,8 +47,7 @@ namespace {
 enum : int {  // The first valid value is 1.
   kAbsoluteSendTimeExtensionId = 1,
   kAudioLevelExtensionId,
-  kGenericDescriptorId00,
+  kGenericDescriptorId,
-  kGenericDescriptorId01,
   kMidExtensionId,
   kRepairedRidExtensionId,
   kRidExtensionId,
@@ -109,9 +108,7 @@ class LoopbackTransportTest : public webrtc::Transport {
         kVideoTimingExtensionId);
     receivers_extensions_.Register<RtpMid>(kMidExtensionId);
     receivers_extensions_.Register<RtpGenericFrameDescriptorExtension00>(
-        kGenericDescriptorId00);
+        kGenericDescriptorId);
-    receivers_extensions_.Register<RtpGenericFrameDescriptorExtension01>(
-        kGenericDescriptorId01);
     receivers_extensions_.Register<RtpStreamId>(kRidExtensionId);
     receivers_extensions_.Register<RepairedRtpStreamId>(
         kRepairedRidExtensionId);

modules/rtp_rtcp/source/rtp_sender_video.cc

@@ -358,12 +358,11 @@ void RTPSenderVideo::AddRtpHeaderExtensions(
       descriptor.attached_structure.release();
     }
 
-    // Do not use v0/v1 generic frame descriptor when v2 is stored.
+    // Do not use generic frame descriptor when dependency descriptor is stored.
     if (!extension_is_set) {
       RtpGenericFrameDescriptor generic_descriptor;
       generic_descriptor.SetFirstPacketInSubFrame(first_packet);
       generic_descriptor.SetLastPacketInSubFrame(last_packet);
-      generic_descriptor.SetDiscardable(video_header.generic->discardable);
 
       if (first_packet) {
         generic_descriptor.SetFrameId(

modules/rtp_rtcp/source/rtp_utility.cc

@@ -534,7 +534,6 @@ void RtpHeaderParser::ParseOneByteExtensionHeader(
           break;
         }
         case kRtpExtensionGenericFrameDescriptor00:
-        case kRtpExtensionGenericFrameDescriptor01:
         case kRtpExtensionGenericFrameDescriptor02:
           RTC_LOG(WARNING)
               << "RtpGenericFrameDescriptor unsupported by rtp header parser.";

test/fuzzers/rtp_packet_fuzzer.cc

@@ -136,11 +136,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
         packet.GetExtension<RtpGenericFrameDescriptorExtension00>(&descriptor);
         break;
       }
-      case kRtpExtensionGenericFrameDescriptor01: {
-        RtpGenericFrameDescriptor descriptor;
-        packet.GetExtension<RtpGenericFrameDescriptorExtension01>(&descriptor);
-        break;
-      }
       case kRtpExtensionColorSpace: {
         ColorSpace color_space;
         packet.GetExtension<ColorSpaceExtension>(&color_space);