Let Call::OnRecoveredPacket parse RTP header extensions.

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 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>
@@ skipping 791 matching lines @@
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     const int kNetworkDelayMs = 100;
     FakeNetworkPipe::Config config;
     config.queue_delay_ms = kNetworkDelayMs;
     return new test::PacketTransport(sender_call, this,
                                      test::PacketTransport::kSender,
                                      test::CallTest::payload_type_map_, config);
   }
 
   void OnFrame(const VideoFrame& video_frame) override {
+    EXPECT_EQ(kVideoRotation_90, video_frame.rotation());
+
     rtc::CritScope lock(&crit_);
     // Rendering frame with timestamp of packet that was dropped -> FEC
     // protection worked.
     auto it = dropped_timestamps_.find(video_frame.timestamp());
     if (it != dropped_timestamps_.end()) {
       if (!expect_flexfec_rtcp_ || received_flexfec_rtcp_) {
         observation_complete_.Set();
       }
     }
   }
@@ skipping 17 matching lines @@
       (*receive_configs)[0].rtp.ulpfec.red_rtx_payload_type =
           test::CallTest::kRtxRedPayloadType;
 
       (*receive_configs)[0].rtp.rtx_ssrc = test::CallTest::kSendRtxSsrcs[0];
       (*receive_configs)[0]
           .rtp.rtx_payload_types[test::CallTest::kVideoSendPayloadType] =
           test::CallTest::kSendRtxPayloadType;
     }
   }
 
+  void OnFrameGeneratorCapturerCreated(
+      test::FrameGeneratorCapturer* frame_generator_capturer) override {
+    frame_generator_capturer->SetFakeRotation(kVideoRotation_90);
+  }
+
   void ModifyFlexfecConfigs(
       std::vector<FlexfecReceiveStream::Config>* receive_configs) override {
     (*receive_configs)[0].local_ssrc = kFlexfecLocalSsrc;
   }
 
   void PerformTest() override {
     EXPECT_TRUE(Wait())
         << "Timed out waiting for dropped frames to be rendered.";
   }
 
@@ skipping 243 matching lines @@
           // details.
           observation_complete_.Set();
         }
         return DROP_PACKET;
       }
 
       return SEND_PACKET;
     }
 
     void OnFrame(const VideoFrame& frame) override {
+      EXPECT_EQ(kVideoRotation_90, frame.rotation());
       {
         rtc::CritScope lock(&crit_);
         if (frame.timestamp() == retransmitted_timestamp_)
           observation_complete_.Set();
         rendered_timestamps_.push_back(frame.timestamp());
       }
       orig_renderer_->OnFrame(frame);
     }
 
     void ModifyVideoConfigs(
@@ skipping 32 matching lines @@
             kSendRtxPayloadType;
       }
       // Configure encoding and decoding with VP8, since generic packetization
       // doesn't support FEC with NACK.
       RTC_DCHECK_EQ(1, (*receive_configs)[0].decoders.size());
       send_config->encoder_settings.encoder = encoder_.get();
       send_config->encoder_settings.payload_name = "VP8";
       (*receive_configs)[0].decoders[0].payload_name = "VP8";
     }
 
+    void OnFrameGeneratorCapturerCreated(
+        test::FrameGeneratorCapturer* frame_generator_capturer) override {
+      frame_generator_capturer->SetFakeRotation(kVideoRotation_90);

[brandtr, 2017/08/21 11:05:32]

Added this to catch similar regressions affecting RTX in the future.

[nisse-webrtc, 2017/08/21 11:54:24]

Nice!

+    }
+
     void PerformTest() override {
       EXPECT_TRUE(Wait())
           << "Timed out while waiting for retransmission to render.";
     }
 
     int GetPayloadType(bool use_rtx, bool use_red) {
       if (use_red) {
         if (use_rtx)
           return kRtxRedPayloadType;
         return kRedPayloadType;
@@ skipping 3666 matching lines @@
     std::unique_ptr<VideoEncoder> encoder_;
     std::unique_ptr<VideoDecoder> decoder_;
     rtc::CriticalSection crit_;
     int recorded_frames_ GUARDED_BY(crit_);
   } test(this);
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc