Don't hardcode MediaType::ANY in FakeNetworkPipe.

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 184 matching lines @@
       event_.Set();
     }
 
     bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
     rtc::Event event_;
   } renderer;
 
   CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
 
-  test::DirectTransport sender_transport(sender_call_.get());
-  test::DirectTransport receiver_transport(receiver_call_.get());
+  test::DirectTransport sender_transport(
+      sender_call_.get(), MediaType::VIDEO);
+  test::DirectTransport receiver_transport(
+      receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
 
   video_receive_configs_[0].renderer = &renderer;
 
   CreateVideoStreams();
   Start();
@@ skipping 25 matching lines @@
 
     void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
 
     bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
     rtc::Event event_;
   } renderer;
 
   CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
 
-  test::DirectTransport sender_transport(sender_call_.get());
-  test::DirectTransport receiver_transport(receiver_call_.get());
+  test::DirectTransport sender_transport(
+      sender_call_.get(), MediaType::VIDEO);
+  test::DirectTransport receiver_transport(
+      receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   video_receive_configs_[0].renderer = &renderer;
 
   CreateVideoStreams();
   Start();
 
@@ skipping 250 matching lines @@
           remote_ssrc_(0),
           receive_transport_(nullptr) {}
 
    private:
     size_t GetNumVideoStreams() const override { return 0; }
     size_t GetNumAudioStreams() const override { return 1; }
 
     test::PacketTransport* CreateReceiveTransport() override {
       test::PacketTransport* receive_transport = new test::PacketTransport(
           nullptr, this, test::PacketTransport::kReceiver,
+          MediaType::AUDIO,
           FakeNetworkPipe::Config());
       receive_transport_ = receive_transport;
       return receive_transport;
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       if (!sequence_number_to_retransmit_) {
@@ skipping 241 matching lines @@
 
     return SEND_PACKET;
   }
 
   test::PacketTransport* CreateSendTransport(Call* sender_call) override {
     // 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, config);
+                                     test::PacketTransport::kSender,
+                                     MediaType::VIDEO, config);
   }
 
   void OnFrame(const VideoFrame& video_frame) override {
     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 158 matching lines @@
       return SEND_PACKET;
     }
 
     test::PacketTransport* CreateSendTransport(Call* sender_call) override {
       // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
       // Configure some network delay.
       const int kNetworkDelayMs = 50;
       FakeNetworkPipe::Config config;
       config.queue_delay_ms = kNetworkDelayMs;
       return new test::PacketTransport(sender_call, this,
-                                       test::PacketTransport::kSender, config);
+                                       test::PacketTransport::kSender,
+                                       MediaType::VIDEO, config);
     }
 
     // TODO(holmer): Investigate why we don't send FEC packets when the bitrate
     // is 10 kbps.
     Call::Config GetSenderCallConfig() override {
       Call::Config config(&event_log_);
       const int kMinBitrateBps = 30000;
       config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
       return config;
     }
@@ skipping 321 matching lines @@
         return delivery_status;
       }
     }
 
     PacketReceiver* receiver_;
     rtc::Event delivered_packet_;
   };
 
   CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
 
-  test::DirectTransport send_transport(sender_call_.get());
-  test::DirectTransport receive_transport(receiver_call_.get());
+  test::DirectTransport send_transport(
+      sender_call_.get(), MediaType::VIDEO);
+  test::DirectTransport receive_transport(
+      receiver_call_.get(), MediaType::VIDEO);
   PacketInputObserver input_observer(receiver_call_->Receiver());
   send_transport.SetReceiver(&input_observer);
   receive_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &send_transport);
   CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
@@ skipping 206 matching lines @@
   // start flowing should this be dereferenced.
   virtual void UpdateSendConfig(
       size_t stream_index,
       VideoSendStream::Config* send_config,
       VideoEncoderConfig* encoder_config,
       test::FrameGeneratorCapturer** frame_generator) {}
   virtual void UpdateReceiveConfig(size_t stream_index,
                                    VideoReceiveStream::Config* receive_config) {
   }
   virtual test::DirectTransport* CreateSendTransport(Call* sender_call) {
-    return new test::DirectTransport(sender_call);
+    return new test::DirectTransport(sender_call, MediaType::VIDEO);
   }
   virtual test::DirectTransport* CreateReceiveTransport(Call* receiver_call) {
-    return new test::DirectTransport(receiver_call);
+    return new test::DirectTransport(receiver_call, MediaType::VIDEO);
   }
 };
 
 // Each renderer verifies that it receives the expected resolution, and as soon
 // as every renderer has received a frame, the test finishes.
 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
   class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
    public:
     VideoOutputObserver(const MultiStreamTest::CodecSettings& settings,
                         uint32_t ssrc,
@@ skipping 58 matching lines @@
 }
 
 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
   static const int kExtensionId = 5;
 
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
     RtpExtensionHeaderObserver(Call* sender_call,
                                const uint32_t& first_media_ssrc,
                                const std::map<uint32_t, uint32_t>& ssrc_map)
-        : DirectTransport(sender_call),
+        : DirectTransport(sender_call, MediaType::VIDEO),
           done_(false, false),
           parser_(RtpHeaderParser::Create()),
           first_media_ssrc_(first_media_ssrc),
           rtx_to_media_ssrcs_(ssrc_map),
           padding_observed_(false),
           rtx_padding_observed_(false),
           retransmit_observed_(false),
           started_(false) {
       parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
                                           kExtensionId);
@@ skipping 295 matching lines @@
     size_t length_;
     FrameType frame_type_;
     rtc::Event called_;
   };
 
   EncodedFrameTestObserver post_encode_observer;
   EncodedFrameTestObserver pre_decode_observer;
 
   CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
 
-  test::DirectTransport sender_transport(sender_call_.get());
-  test::DirectTransport receiver_transport(receiver_call_.get());
+  test::DirectTransport sender_transport(
+      sender_call_.get(), MediaType::VIDEO);
+  test::DirectTransport receiver_transport(
+      receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   video_send_config_.post_encode_callback = &post_encode_observer;
   video_receive_configs_[0].pre_decode_callback = &pre_decode_observer;
 
   CreateVideoStreams();
   Start();
@@ skipping 143 matching lines @@
                          this,
                          "BitrateStatsPollingThread"),
           state_(kWaitForFirstRampUp),
           retransmission_rate_limiter_(clock_, 1000) {}
 
     ~BweObserver() {}
 
     test::PacketTransport* CreateReceiveTransport() override {
       receive_transport_ = new test::PacketTransport(
           nullptr, this, test::PacketTransport::kReceiver,
+          MediaType::VIDEO,
           FakeNetworkPipe::Config());
       return receive_transport_;
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config(&event_log_);
       // Set a high start bitrate to reduce the test completion time.
       config.bitrate_config.start_bitrate_bps = remb_bitrate_bps_;
       return config;
     }
@@ skipping 943 matching lines @@
         if (!stat.second)
           return false;
       }
       return true;
     }
 
     test::PacketTransport* CreateSendTransport(Call* sender_call) override {
       FakeNetworkPipe::Config network_config;
       network_config.loss_percent = 5;
       return new test::PacketTransport(
-          sender_call, this, test::PacketTransport::kSender, network_config);
+          sender_call, this, test::PacketTransport::kSender, MediaType::VIDEO,
+          network_config);
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config = EndToEndTest::GetSenderCallConfig();
       config.bitrate_config.start_bitrate_bps = kStartBitrateBps;
       return config;
     }
 
     // This test use other VideoStream settings than the the default settings
     // implemented in DefaultVideoStreamFactory. Therefore  this test implement
@@ skipping 533 matching lines @@
     rtc::CriticalSection crit_;
     size_t ssrcs_to_observe_ GUARDED_BY(crit_);
     std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
   } observer(use_rtx);
 
   Call::Config config(&event_log_);
   CreateCalls(config, config);
 
   test::PacketTransport send_transport(sender_call_.get(), &observer,
                                        test::PacketTransport::kSender,
+                                       MediaType::VIDEO,
                                        FakeNetworkPipe::Config());
   test::PacketTransport receive_transport(nullptr, &observer,
                                           test::PacketTransport::kReceiver,
+                                          MediaType::VIDEO,
                                           FakeNetworkPipe::Config());
   send_transport.SetReceiver(receiver_call_->Receiver());
   receive_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(kNumSsrcs, 0, 0, &send_transport);
 
   if (use_rtx) {
     for (size_t i = 0; i < kNumSsrcs; ++i) {
       video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
     }
@@ skipping 272 matching lines @@
   RunBaseTest(&test);
 }
 
 TEST_F(EndToEndTest, CallReportsRttForSender) {
   static const int kSendDelayMs = 30;
   static const int kReceiveDelayMs = 70;
   CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
 
   FakeNetworkPipe::Config config;
   config.queue_delay_ms = kSendDelayMs;
-  test::DirectTransport sender_transport(config, sender_call_.get());
+  test::DirectTransport sender_transport(
+      config, sender_call_.get(), MediaType::VIDEO);
   config.queue_delay_ms = kReceiveDelayMs;
-  test::DirectTransport receiver_transport(config, receiver_call_.get());
+  test::DirectTransport receiver_transport(
+      config, receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
 
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
   Start();
@@ skipping 41 matching lines @@
   DestroyStreams();
 }
 
 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
     MediaType network_to_bring_up,
     Transport* transport) {
   Call::Config config(&event_log_);
   CreateCalls(config, config);
   receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
 
-  test::DirectTransport sender_transport(sender_call_.get());
+  test::DirectTransport sender_transport(sender_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(transport);
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
 
   Start();
   SleepMs(kSilenceTimeoutMs);
   Stop();
@@ skipping 303 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