Reland of Don't hardcode MediaType::ANY in FakeNetworkPipe.

webrtc/test/call_test.h

 /*
  *  Copyright (c) 2014 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.
  */
 #ifndef WEBRTC_TEST_CALL_TEST_H_
@@ skipping 41 matching lines @@
   static const uint8_t kAudioSendPayloadType;
   static const uint32_t kSendRtxSsrcs[kNumSsrcs];
   static const uint32_t kVideoSendSsrcs[kNumSsrcs];
   static const uint32_t kAudioSendSsrc;
   static const uint32_t kFlexfecSendSsrc;
   static const uint32_t kReceiverLocalVideoSsrc;
   static const uint32_t kReceiverLocalAudioSsrc;
   static const int kNackRtpHistoryMs;
 
  protected:
+  // Needed for tests sending both audio and video on the same
+  // FakeNetworkPipe. We then need to set correct MediaType based on
+  // packet payload type, before passing the packet on to Call.
+  class PayloadDemuxer : public PacketReceiver {

[stefan-webrtc, 2017/03/29 12:27:25]

It seems like PacketReceiver is the wrong type for this, since we don't actually
know the MediaType of the packet at this point. Should it insetad inherit from
something else, e.g., webrtc::Transport?

[nisse-webrtc, 2017/03/29 12:37:55]

We can't, since this object is intended to be passed to
FakeNetworkPipe::SetReceiver.

[stefan-webrtc, 2017/03/30 06:47:11]

Ah, ok. I guess we could if we changed the FakeNetworkPipe? If you think that
makes sense maybe you could leave a TODO here?

[nisse-webrtc, 2017/03/30 06:56:45]

For now, I think it makes sense for most tests to configure FakeNetworkPipe with
a media type. If we do any refactorings there, it might make sense to make media
type be a per-packet property in 
FakeNetworkPipe. But it's unclear what changes would be needed at input to the
FakeNetworkPipe to get that right.

+   public:
+    PayloadDemuxer() = default;
+
+    void SetReceiver(PacketReceiver* receiver);
+    DeliveryStatus DeliverPacket(MediaType media_type,
+                                 const uint8_t* packet,
+                                 size_t length,
+                                 const PacketTime& packet_time) override;
+
+   private:
+    PacketReceiver* receiver_ = nullptr;
+  };
+
   // RunBaseTest overwrites the audio_state and the voice_engine of the send and
   // receive Call configs to simplify test code and avoid having old VoiceEngine
   // APIs in the tests.
   void RunBaseTest(BaseTest* test);
 
   void CreateCalls(const Call::Config& sender_config,
                    const Call::Config& receiver_config);
   void CreateSenderCall(const Call::Config& config);
   void CreateReceiverCall(const Call::Config& config);
   void DestroyCalls();
@@ skipping 45 matching lines @@
 
   std::unique_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
   test::FakeEncoder fake_encoder_;
   std::vector<std::unique_ptr<VideoDecoder>> allocated_decoders_;
   size_t num_video_streams_;
   size_t num_audio_streams_;
   size_t num_flexfec_streams_;
   rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
   test::FakeVideoRenderer fake_renderer_;
 
+  PayloadDemuxer receive_demuxer_;
+  PayloadDemuxer send_demuxer_;
+
  private:
   // TODO(holmer): Remove once VoiceEngine is fully refactored to the new API.
   // These methods are used to set up legacy voice engines and channels which is
   // necessary while voice engine is being refactored to the new stream API.
   struct VoiceEngineState {
     VoiceEngineState()
         : voice_engine(nullptr),
           base(nullptr),
           channel_id(-1) {}
 
@@ skipping 28 matching lines @@
 
   virtual std::unique_ptr<FakeAudioDevice::Capturer> CreateCapturer();
   virtual std::unique_ptr<FakeAudioDevice::Renderer> CreateRenderer();
   virtual void OnFakeAudioDevicesCreated(FakeAudioDevice* send_audio_device,
                                          FakeAudioDevice* recv_audio_device);
 
   virtual Call::Config GetSenderCallConfig();
   virtual Call::Config GetReceiverCallConfig();
   virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
 
+  // The default implementation creates MediaType::VIDEO transports.
   virtual test::PacketTransport* CreateSendTransport(Call* sender_call);
   virtual test::PacketTransport* CreateReceiveTransport();
 
   virtual void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config);
   virtual void ModifyVideoCaptureStartResolution(int* width,
                                                  int* heigt,
                                                  int* frame_rate);
@@ skipping 33 matching lines @@
   EndToEndTest();
   explicit EndToEndTest(unsigned int timeout_ms);
 
   bool ShouldCreateReceivers() const override;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_TEST_CALL_TEST_H_