Remove use of RtpHeaderExtension and clean up

webrtc/media/engine/webrtcvideoengine2_unittest.cc

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/media/base/testutils.h"
 #include "webrtc/media/base/videoengine_unittest.h"
 #include "webrtc/media/engine/fakewebrtccall.h"
 #include "webrtc/media/engine/fakewebrtcvideoengine.h"
 #include "webrtc/media/engine/simulcast.h"
 #include "webrtc/media/engine/webrtcvideochannelfactory.h"
 #include "webrtc/media/engine/webrtcvideoengine2.h"
 #include "webrtc/media/engine/webrtcvoiceengine.h"
 #include "webrtc/test/field_trial.h"
 #include "webrtc/video_encoder.h"
 
+using webrtc::RtpExtension;
+
 namespace {
 static const int kDefaultQpMax = 56;
 static const int kDefaultFramerate = 30;
 
 static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30);
 static const cricket::VideoCodec kVp8Codec360p(100, "VP8", 640, 360, 30);
 static const cricket::VideoCodec kVp8Codec270p(100, "VP8", 480, 270, 30);
 
 static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30);
 static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30);
@@ skipping 135 matching lines @@
                                           &associated_payload_type));
     EXPECT_EQ(default_codec_.id, associated_payload_type);
     return;
   }
   FAIL() << "No RTX codec found among default codecs.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, SupportsTimestampOffsetHeaderExtension) {
   RtpCapabilities capabilities = engine_.GetCapabilities();
   ASSERT_FALSE(capabilities.header_extensions.empty());
-  for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
-    if (extension.uri == kRtpTimestampOffsetHeaderExtension) {
-      EXPECT_EQ(kRtpTimestampOffsetHeaderExtensionDefaultId, extension.id);
+  for (const RtpExtension& extension : capabilities.header_extensions) {
+    if (extension.uri == RtpExtension::kTimestampOffsetUri) {
+      EXPECT_EQ(RtpExtension::kTimestampOffsetDefaultId, extension.id);
       return;
     }
   }
   FAIL() << "Timestamp offset extension not in header-extension list.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
   RtpCapabilities capabilities = engine_.GetCapabilities();
   ASSERT_FALSE(capabilities.header_extensions.empty());
-  for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
-    if (extension.uri == kRtpAbsoluteSenderTimeHeaderExtension) {
-      EXPECT_EQ(kRtpAbsoluteSenderTimeHeaderExtensionDefaultId, extension.id);
+  for (const RtpExtension& extension : capabilities.header_extensions) {
+    if (extension.uri == RtpExtension::kAbsSendTimeUri) {
+      EXPECT_EQ(RtpExtension::kAbsSendTimeDefaultId, extension.id);
       return;
     }
   }
   FAIL() << "Absolute Sender Time extension not in header-extension list.";
 }
 
 class WebRtcVideoEngine2WithSendSideBweTest : public WebRtcVideoEngine2Test {
  public:
   WebRtcVideoEngine2WithSendSideBweTest()
       : WebRtcVideoEngine2Test("WebRTC-SendSideBwe/Enabled/") {}
 };
 
 TEST_F(WebRtcVideoEngine2WithSendSideBweTest,
        SupportsTransportSequenceNumberHeaderExtension) {
   RtpCapabilities capabilities = engine_.GetCapabilities();
   ASSERT_FALSE(capabilities.header_extensions.empty());
-  for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
-    if (extension.uri == kRtpTransportSequenceNumberHeaderExtension) {
-      EXPECT_EQ(kRtpTransportSequenceNumberHeaderExtensionDefaultId,
-                extension.id);
+  for (const RtpExtension& extension : capabilities.header_extensions) {
+    if (extension.uri == RtpExtension::kTransportSequenceNumberUri) {
+      EXPECT_EQ(RtpExtension::kTransportSequenceNumberDefaultId, extension.id);
       return;
     }
   }
   FAIL() << "Transport sequence number extension not in header-extension list.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, SupportsVideoRotationHeaderExtension) {
   RtpCapabilities capabilities = engine_.GetCapabilities();
   ASSERT_FALSE(capabilities.header_extensions.empty());
-  for (const RtpHeaderExtension& extension : capabilities.header_extensions) {
-    if (extension.uri == kRtpVideoRotationHeaderExtension) {
-      EXPECT_EQ(kRtpVideoRotationHeaderExtensionDefaultId, extension.id);
+  for (const RtpExtension& extension : capabilities.header_extensions) {
+    if (extension.uri == RtpExtension::kVideoRotationUri) {
+      EXPECT_EQ(RtpExtension::kVideoRotationDefaultId, extension.id);
       return;
     }
   }
   FAIL() << "Video Rotation extension not in header-extension list.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
   // Allocate the capturer first to prevent early destruction before channel's
   // dtor is called.
   cricket::FakeVideoCapturer capturer;
 
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp8Codec);
 
   std::unique_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
 
   // Add CVO extension.
   const int id = 1;
   parameters.extensions.push_back(
-      cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
+      RtpExtension(RtpExtension::kVideoRotationUri, id));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   // Set capturer.
   channel->SetSource(kSsrc, &capturer);
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.GetApplyRotation());
 
   // Verify removing header extension turns on applying rotation.
   parameters.extensions.clear();
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(capturer.GetApplyRotation());
 }
 
 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) {
   // Allocate the capturer first to prevent early destruction before channel's
   // dtor is called.
   cricket::FakeVideoCapturer capturer;
 
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp8Codec);
 
   std::unique_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
   // Add CVO extension.
   const int id = 1;
   parameters.extensions.push_back(
-      cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
+      RtpExtension(RtpExtension::kVideoRotationUri, id));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
 
   // Set capturer.
   channel->SetSource(kSsrc, &capturer);
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.GetApplyRotation());
 }
 
@@ skipping 13 matching lines @@
 
   // Set capturer.
   channel->SetSource(kSsrc, &capturer);
 
   // Verify capturer has turned on applying rotation.
   EXPECT_TRUE(capturer.GetApplyRotation());
 
   // Add CVO extension.
   const int id = 1;
   parameters.extensions.push_back(
-      cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
+      RtpExtension(RtpExtension::kVideoRotationUri, id));
   // Also remove the first codec to trigger a codec change as well.
   parameters.codecs.erase(parameters.codecs.begin());
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.GetApplyRotation());
 
   // Verify removing header extension turns on applying rotation.
   parameters.extensions.clear();
   EXPECT_TRUE(channel->SetSendParameters(parameters));
@@ skipping 630 matching lines @@
     EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
     EXPECT_EQ(expected_min_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
     EXPECT_EQ(expected_start_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
     EXPECT_EQ(expected_max_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
   }
 
-  void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
-                                      const std::string& webrtc_ext) {
+  void TestSetSendRtpHeaderExtensions(const std::string& ext_uri) {
     // Enable extension.
     const int id = 1;
     cricket::VideoSendParameters parameters = send_parameters_;
-    parameters.extensions.push_back(
-        cricket::RtpHeaderExtension(cricket_ext, id));
+    parameters.extensions.push_back(RtpExtension(ext_uri, id));
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
     FakeVideoSendStream* send_stream =
         AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify the send extension id.
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
-    EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
+    EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
     // Verify call with same set of extensions returns true.
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
     // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
     // receivers.
     EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
                     ->GetConfig()
                     .rtp.extensions.empty());
 
     // Verify that existing RTP header extensions can be removed.
     EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
     send_stream = fake_call_->GetVideoSendStreams()[0];
     EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
 
     // Verify that adding receive RTP header extensions adds them for existing
     // streams.
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
     send_stream = fake_call_->GetVideoSendStreams()[0];
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
-    EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
+    EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
   }
 
-  void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
-                                      const std::string& webrtc_ext) {
+  void TestSetRecvRtpHeaderExtensions(const std::string& ext_uri) {
     // Enable extension.
     const int id = 1;
     cricket::VideoRecvParameters parameters = recv_parameters_;
-    parameters.extensions.push_back(
-        cricket::RtpHeaderExtension(cricket_ext, id));
+    parameters.extensions.push_back(RtpExtension(ext_uri, id));
     EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
     FakeVideoReceiveStream* recv_stream =
         AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify the recv extension id.
     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
-    EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
+    EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
     // Verify call with same set of extensions returns true.
     EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
     // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
     // senders.
     EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
                     ->GetConfig()
                     .rtp.extensions.empty());
 
     // Verify that existing RTP header extensions can be removed.
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
     ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
     recv_stream = fake_call_->GetVideoReceiveStreams()[0];
     EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
 
     // Verify that adding receive RTP header extensions adds them for existing
     // streams.
     EXPECT_TRUE(channel_->SetRecvParameters(parameters));
     recv_stream = fake_call_->GetVideoReceiveStreams()[0];
     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
-    EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
+    EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
   }
 
   void TestExtensionFilter(const std::vector<std::string>& extensions,
                            const std::string& expected_extension) {
     cricket::VideoSendParameters parameters = send_parameters_;
     int expected_id = -1;
     int id = 1;
     for (const std::string& extension : extensions) {
       if (extension == expected_extension)
         expected_id = id;
-      parameters.extensions.push_back(
-          cricket::RtpHeaderExtension(extension, id++));
+      parameters.extensions.push_back(RtpExtension(extension, id++));
     }
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
     FakeVideoSendStream* send_stream =
         AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify that only one of them has been set, and that it is the one with
     // highest priority (transport sequence number).
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(expected_extension,
-              send_stream->GetConfig().rtp.extensions[0].name);
+              send_stream->GetConfig().rtp.extensions[0].uri);
   }
 
   void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
   void TestReceiverLocalSsrcConfiguration(bool receiver_first);
   void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
                                         bool expect_created_receive_stream);
 
   FakeVideoSendStream* SetDenoisingOption(
       uint32_t ssrc,
       cricket::FakeVideoCapturer* capturer,
@@ skipping 134 matching lines @@
       AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
   ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
 
   FakeVideoReceiveStream* recv_stream =
       AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
   ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
 }
 
 // Test support for RTP timestamp offset header extension.
 TEST_F(WebRtcVideoChannel2Test, SendRtpTimestampOffsetHeaderExtensions) {
-  TestSetSendRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
-                                 webrtc::RtpExtension::kTOffset);
+  TestSetSendRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
 }
+
 TEST_F(WebRtcVideoChannel2Test, RecvRtpTimestampOffsetHeaderExtensions) {
-  TestSetRecvRtpHeaderExtensions(kRtpTimestampOffsetHeaderExtension,
-                                 webrtc::RtpExtension::kTOffset);
+  TestSetRecvRtpHeaderExtensions(RtpExtension::kTimestampOffsetUri);
 }
 
 // Test support for absolute send time header extension.
 TEST_F(WebRtcVideoChannel2Test, SendAbsoluteSendTimeHeaderExtensions) {
-  TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
-                                 webrtc::RtpExtension::kAbsSendTime);
+  TestSetSendRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
 }
+
 TEST_F(WebRtcVideoChannel2Test, RecvAbsoluteSendTimeHeaderExtensions) {
-  TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension,
-                                 webrtc::RtpExtension::kAbsSendTime);
+  TestSetRecvRtpHeaderExtensions(RtpExtension::kAbsSendTimeUri);
 }
 
 TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksTransportSeqNum) {
   // Enable three redundant extensions.
   std::vector<std::string> extensions;
-  extensions.push_back(kRtpAbsoluteSenderTimeHeaderExtension);
-  extensions.push_back(kRtpTimestampOffsetHeaderExtension);
-  extensions.push_back(kRtpTransportSequenceNumberHeaderExtension);
-  TestExtensionFilter(extensions, kRtpTransportSequenceNumberHeaderExtension);
+  extensions.push_back(RtpExtension::kAbsSendTimeUri);
+  extensions.push_back(RtpExtension::kTimestampOffsetUri);
+  extensions.push_back(RtpExtension::kTransportSequenceNumberUri);
+  TestExtensionFilter(extensions, RtpExtension::kTransportSequenceNumberUri);
 }
 
 TEST_F(WebRtcVideoChannel2Test, FiltersExtensionsPicksAbsSendTime) {
   // Enable two redundant extensions.
   std::vector<std::string> extensions;
-  extensions.push_back(kRtpAbsoluteSenderTimeHeaderExtension);
-  extensions.push_back(kRtpTimestampOffsetHeaderExtension);
-  TestExtensionFilter(extensions, kRtpAbsoluteSenderTimeHeaderExtension);
+  extensions.push_back(RtpExtension::kAbsSendTimeUri);
+  extensions.push_back(RtpExtension::kTimestampOffsetUri);
+  TestExtensionFilter(extensions, RtpExtension::kAbsSendTimeUri);
 }
 
 class WebRtcVideoChannel2WithSendSideBweTest : public WebRtcVideoChannel2Test {
  public:
   WebRtcVideoChannel2WithSendSideBweTest()
       : WebRtcVideoChannel2Test("WebRTC-SendSideBwe/Enabled/") {}
 };
 
 // Test support for transport sequence number header extension.
 TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
        SendTransportSequenceNumberHeaderExtensions) {
-  TestSetSendRtpHeaderExtensions(
-      kRtpTransportSequenceNumberHeaderExtension,
-      webrtc::RtpExtension::kTransportSequenceNumber);
+  TestSetSendRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
 }
 TEST_F(WebRtcVideoChannel2WithSendSideBweTest,
        RecvTransportSequenceNumberHeaderExtensions) {
-  TestSetRecvRtpHeaderExtensions(
-      kRtpTransportSequenceNumberHeaderExtension,
-      webrtc::RtpExtension::kTransportSequenceNumber);
+  TestSetRecvRtpHeaderExtensions(RtpExtension::kTransportSequenceNumberUri);
 }
 
 // Test support for video rotation header extension.
 TEST_F(WebRtcVideoChannel2Test, SendVideoRotationHeaderExtensions) {
-  TestSetSendRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
-                                 webrtc::RtpExtension::kVideoRotation);
+  TestSetSendRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
 }
 TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) {
-  TestSetRecvRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
-                                 webrtc::RtpExtension::kVideoRotation);
+  TestSetRecvRtpHeaderExtensions(RtpExtension::kVideoRotationUri);
 }
 
 TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
   const int kAbsSendTimeId = 1;
   const int kVideoRotationId = 2;
-  send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
-      kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
-  send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
-      kRtpVideoRotationHeaderExtension, kVideoRotationId));
+  send_parameters_.extensions.push_back(
+      RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
+  send_parameters_.extensions.push_back(
+      RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
 
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   FakeVideoSendStream* send_stream =
       AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
   ASSERT_EQ(2u, send_stream->GetConfig().rtp.extensions.size());
 
   // Setting the same extensions (even if in different order) shouldn't
   // reallocate the stream.
   std::reverse(send_parameters_.extensions.begin(),
                send_parameters_.extensions.end());
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
 
   // Setting different extensions should recreate the stream.
   send_parameters_.extensions.resize(1);
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
 }
 
 TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
   const int kTOffsetId = 1;
   const int kAbsSendTimeId = 2;
   const int kVideoRotationId = 3;
-  recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
-      kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
-  recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
-      kRtpTimestampOffsetHeaderExtension, kTOffsetId));
-  recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
-      kRtpVideoRotationHeaderExtension, kVideoRotationId));
+  recv_parameters_.extensions.push_back(
+      RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
+  recv_parameters_.extensions.push_back(
+      RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
+  recv_parameters_.extensions.push_back(
+      RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
 
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
   FakeVideoReceiveStream* recv_stream =
       AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
   ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
 
   // Setting the same extensions (even if in different order) shouldn't
   // reallocate the stream.
   std::reverse(recv_parameters_.extensions.begin(),
                recv_parameters_.extensions.end());
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
 
   // Setting different extensions should recreate the stream.
   recv_parameters_.extensions.resize(1);
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
   const int kUnsupportedId = 1;
   const int kTOffsetId = 2;
 
   send_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
+      RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
   send_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
+      RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   FakeVideoSendStream* send_stream =
       AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
   // Only timestamp offset extension is set to send stream,
   // unsupported rtp extension is ignored.
   ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
-  EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
-               send_stream->GetConfig().rtp.extensions[0].name.c_str());
+  EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
+               send_stream->GetConfig().rtp.extensions[0].uri.c_str());
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
   const int kUnsupportedId = 1;
   const int kTOffsetId = 2;
 
   recv_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
+      RtpExtension(kUnsupportedExtensionName, kUnsupportedId));
   recv_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
+      RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
   FakeVideoReceiveStream* recv_stream =
       AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
   // Only timestamp offset extension is set to receive stream,
   // unsupported rtp extension is ignored.
   ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
-  EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
-               recv_stream->GetConfig().rtp.extensions[0].name.c_str());
+  EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
+               recv_stream->GetConfig().rtp.extensions[0].uri.c_str());
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
   const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
   for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
-    send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
-        webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
+    send_parameters_.extensions.push_back(
+        RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
     EXPECT_FALSE(channel_->SetSendParameters(send_parameters_))
         << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
   }
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
   const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
   for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
-    recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
-        webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
+    recv_parameters_.extensions.push_back(
+        RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i]));
     EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_))
         << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
   }
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
   const int id = 1;
   send_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
+      RtpExtension(RtpExtension::kTimestampOffsetUri, id));
   send_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
+      RtpExtension(RtpExtension::kAbsSendTimeUri, id));
   EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
 
   // Duplicate entries are also not supported.
   send_parameters_.extensions.clear();
   send_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
+      RtpExtension(RtpExtension::kTimestampOffsetUri, id));
   send_parameters_.extensions.push_back(send_parameters_.extensions.back());
   EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
   const int id = 1;
   recv_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
+      RtpExtension(RtpExtension::kTimestampOffsetUri, id));
   recv_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
+      RtpExtension(RtpExtension::kAbsSendTimeUri, id));
   EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
 
   // Duplicate entries are also not supported.
   recv_parameters_.extensions.clear();
   recv_parameters_.extensions.push_back(
-      cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
+      RtpExtension(RtpExtension::kTimestampOffsetUri, id));
   recv_parameters_.extensions.push_back(recv_parameters_.extensions.back());
   EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
 }
 
 TEST_F(WebRtcVideoChannel2Test, AddRecvStreamOnlyUsesOneReceiveStream) {
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
 }
 
 TEST_F(WebRtcVideoChannel2Test, RtcpIsCompoundByDefault) {
@@ skipping 2330 matching lines @@
 }
 
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
   cricket::VideoCodec codec(kVp8Codec270p);
   codec.width += 1;
   codec.height += 1;
   VerifySimulcastSettings(codec, 2, 2);
 }
 }  // namespace cricket