Add m-esr52 at 52.6.0

1 files changed, 720 insertions, 0 deletions

diff --git a/media/webrtc/signaling/test/mediapipeline_unittest.cpp b/media/webrtc/signaling/test/mediapipeline_unittest.cpp
new file mode 100644
index 000000000..33518218b
--- /dev/null
+++ b/media/webrtc/signaling/test/mediapipeline_unittest.cpp
@@ -0,0 +1,720 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+#include <iostream>
+
+#include "sigslot.h"
+
+#include "logging.h"
+#include "nsThreadUtils.h"
+#include "nsXPCOM.h"
+#include "nss.h"
+#include "ssl.h"
+#include "sslproto.h"
+
+#include "dtlsidentity.h"
+#include "mozilla/RefPtr.h"
+#include "FakeMediaStreams.h"
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+#include "MediaConduitErrors.h"
+#include "MediaConduitInterface.h"
+#include "MediaPipeline.h"
+#include "MediaPipelineFilter.h"
+#include "runnable_utils.h"
+#include "transportflow.h"
+#include "transportlayerloopback.h"
+#include "transportlayerdtls.h"
+#include "mozilla/SyncRunnable.h"
+
+
+#include "mtransport_test_utils.h"
+#include "runnable_utils.h"
+
+#include "webrtc/modules/interface/module_common_types.h"
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#include "TestHarness.h"
+
+using namespace mozilla;
+MOZ_MTLOG_MODULE("mediapipeline")
+
+MtransportTestUtils *test_utils;
+
+namespace {
+
+class TransportInfo {
+ public:
+  TransportInfo() :
+    flow_(nullptr),
+    loopback_(nullptr),
+    dtls_(nullptr) {}
+
+  static void InitAndConnect(TransportInfo &client, TransportInfo &server) {
+    client.Init(true);
+    server.Init(false);
+    client.PushLayers();
+    server.PushLayers();
+    client.Connect(&server);
+    server.Connect(&client);
+  }
+
+  void Init(bool client) {
+    nsresult res;
+
+    flow_ = new TransportFlow();
+    loopback_ = new TransportLayerLoopback();
+    dtls_ = new TransportLayerDtls();
+
+    res = loopback_->Init();
+    if (res != NS_OK) {
+      FreeLayers();
+    }
+    ASSERT_EQ((nsresult)NS_OK, res);
+
+    std::vector<uint16_t> ciphers;
+    ciphers.push_back(SRTP_AES128_CM_HMAC_SHA1_80);
+    dtls_->SetSrtpCiphers(ciphers);
+    dtls_->SetIdentity(DtlsIdentity::Generate());
+    dtls_->SetRole(client ? TransportLayerDtls::CLIENT :
+      TransportLayerDtls::SERVER);
+    dtls_->SetVerificationAllowAll();
+  }
+
+  void PushLayers() {
+    nsresult res;
+
+    nsAutoPtr<std::queue<TransportLayer *> > layers(
+      new std::queue<TransportLayer *>);
+    layers->push(loopback_);
+    layers->push(dtls_);
+    res = flow_->PushLayers(layers);
+    if (res != NS_OK) {
+      FreeLayers();
+    }
+    ASSERT_EQ((nsresult)NS_OK, res);
+  }
+
+  void Connect(TransportInfo* peer) {
+    MOZ_ASSERT(loopback_);
+    MOZ_ASSERT(peer->loopback_);
+
+    loopback_->Connect(peer->loopback_);
+  }
+
+  // Free the memory allocated at the beginning of Init
+  // if failure occurs before layers setup.
+  void FreeLayers() {
+    delete loopback_;
+    loopback_ = nullptr;
+    delete dtls_;
+    dtls_ = nullptr;
+  }
+
+  void Shutdown() {
+    if (loopback_) {
+      loopback_->Disconnect();
+    }
+    loopback_ = nullptr;
+    dtls_ = nullptr;
+    flow_ = nullptr;
+  }
+
+  RefPtr<TransportFlow> flow_;
+  TransportLayerLoopback *loopback_;
+  TransportLayerDtls *dtls_;
+};
+
+class TestAgent {
+ public:
+  TestAgent() :
+      audio_config_(109, "opus", 48000, 960, 2, 64000, false),
+      audio_conduit_(mozilla::AudioSessionConduit::Create()),
+      audio_(),
+      audio_pipeline_() {
+  }
+
+  static void ConnectRtp(TestAgent *client, TestAgent *server) {
+    TransportInfo::InitAndConnect(client->audio_rtp_transport_,
+                                  server->audio_rtp_transport_);
+  }
+
+  static void ConnectRtcp(TestAgent *client, TestAgent *server) {
+    TransportInfo::InitAndConnect(client->audio_rtcp_transport_,
+                                  server->audio_rtcp_transport_);
+  }
+
+  static void ConnectBundle(TestAgent *client, TestAgent *server) {
+    TransportInfo::InitAndConnect(client->bundle_transport_,
+                                  server->bundle_transport_);
+  }
+
+  virtual void CreatePipelines_s(bool aIsRtcpMux) = 0;
+
+  void Start() {
+    nsresult ret;
+
+    MOZ_MTLOG(ML_DEBUG, "Starting");
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnableRet(&ret, audio_->GetStream(), &Fake_MediaStream::Start));
+
+    ASSERT_TRUE(NS_SUCCEEDED(ret));
+  }
+
+  void StopInt() {
+    audio_->GetStream()->Stop();
+  }
+
+  void Stop() {
+    MOZ_MTLOG(ML_DEBUG, "Stopping");
+
+    if (audio_pipeline_)
+      audio_pipeline_->ShutdownMedia_m();
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnable(this, &TestAgent::StopInt));
+  }
+
+  void Shutdown_s() {
+    audio_rtp_transport_.Shutdown();
+    audio_rtcp_transport_.Shutdown();
+    bundle_transport_.Shutdown();
+    if (audio_pipeline_)
+      audio_pipeline_->DetachTransport_s();
+  }
+
+  void Shutdown() {
+    if (audio_pipeline_)
+      audio_pipeline_->ShutdownMedia_m();
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnable(this, &TestAgent::Shutdown_s));
+  }
+
+  uint32_t GetRemoteSSRC() {
+    uint32_t res = 0;
+    audio_conduit_->GetRemoteSSRC(&res);
+    return res;
+  }
+
+  uint32_t GetLocalSSRC() {
+    uint32_t res = 0;
+    audio_conduit_->GetLocalSSRC(&res);
+    return res;
+  }
+
+  int GetAudioRtpCountSent() {
+    return audio_pipeline_->rtp_packets_sent();
+  }
+
+  int GetAudioRtpCountReceived() {
+    return audio_pipeline_->rtp_packets_received();
+  }
+
+  int GetAudioRtcpCountSent() {
+    return audio_pipeline_->rtcp_packets_sent();
+  }
+
+  int GetAudioRtcpCountReceived() {
+    return audio_pipeline_->rtcp_packets_received();
+  }
+
+ protected:
+  mozilla::AudioCodecConfig audio_config_;
+  RefPtr<mozilla::MediaSessionConduit> audio_conduit_;
+  RefPtr<DOMMediaStream> audio_;
+  // TODO(bcampen@mozilla.com): Right now this does not let us test RTCP in
+  // both directions; only the sender's RTCP is sent, but the receiver should
+  // be sending it too.
+  RefPtr<mozilla::MediaPipeline> audio_pipeline_;
+  TransportInfo audio_rtp_transport_;
+  TransportInfo audio_rtcp_transport_;
+  TransportInfo bundle_transport_;
+};
+
+class TestAgentSend : public TestAgent {
+ public:
+  TestAgentSend() : use_bundle_(false) {}
+
+  virtual void CreatePipelines_s(bool aIsRtcpMux) {
+    audio_ = new Fake_DOMMediaStream(new Fake_AudioStreamSource());
+    audio_->SetHintContents(Fake_DOMMediaStream::HINT_CONTENTS_AUDIO);
+
+    nsTArray<RefPtr<Fake_MediaStreamTrack>> tracks;
+    audio_->GetAudioTracks(tracks);
+    ASSERT_EQ(1U, tracks.Length());
+
+    mozilla::MediaConduitErrorCode err =
+        static_cast<mozilla::AudioSessionConduit *>(audio_conduit_.get())->
+        ConfigureSendMediaCodec(&audio_config_);
+    EXPECT_EQ(mozilla::kMediaConduitNoError, err);
+
+    std::string test_pc("PC");
+
+    if (aIsRtcpMux) {
+      ASSERT_FALSE(audio_rtcp_transport_.flow_);
+    }
+
+    RefPtr<TransportFlow> rtp(audio_rtp_transport_.flow_);
+    RefPtr<TransportFlow> rtcp(audio_rtcp_transport_.flow_);
+
+    if (use_bundle_) {
+      rtp = bundle_transport_.flow_;
+      rtcp = nullptr;
+    }
+
+    audio_pipeline_ = new mozilla::MediaPipelineTransmit(
+        test_pc,
+        nullptr,
+        test_utils->sts_target(),
+        tracks[0],
+        "audio_track_fake_uuid",
+        1,
+        audio_conduit_,
+        rtp,
+        rtcp,
+        nsAutoPtr<MediaPipelineFilter>());
+
+    audio_pipeline_->Init();
+  }
+
+  void SetUsingBundle(bool use_bundle) {
+    use_bundle_ = use_bundle;
+  }
+
+ private:
+  bool use_bundle_;
+};
+
+
+class TestAgentReceive : public TestAgent {
+ public:
+  virtual void CreatePipelines_s(bool aIsRtcpMux) {
+    mozilla::SourceMediaStream *audio = new Fake_SourceMediaStream();
+    audio->SetPullEnabled(true);
+
+    mozilla::AudioSegment* segment= new mozilla::AudioSegment();
+    audio->AddAudioTrack(0, 100, 0, segment);
+    audio->AdvanceKnownTracksTime(mozilla::STREAM_TIME_MAX);
+
+    audio_ = new Fake_DOMMediaStream(audio);
+
+    std::vector<mozilla::AudioCodecConfig *> codecs;
+    codecs.push_back(&audio_config_);
+
+    mozilla::MediaConduitErrorCode err =
+        static_cast<mozilla::AudioSessionConduit *>(audio_conduit_.get())->
+        ConfigureRecvMediaCodecs(codecs);
+    EXPECT_EQ(mozilla::kMediaConduitNoError, err);
+
+    std::string test_pc("PC");
+
+    if (aIsRtcpMux) {
+      ASSERT_FALSE(audio_rtcp_transport_.flow_);
+    }
+
+    audio_pipeline_ = new mozilla::MediaPipelineReceiveAudio(
+        test_pc,
+        nullptr,
+        test_utils->sts_target(),
+        audio_->GetStream()->AsSourceStream(), "audio_track_fake_uuid", 1, 1,
+        static_cast<mozilla::AudioSessionConduit *>(audio_conduit_.get()),
+        audio_rtp_transport_.flow_,
+        audio_rtcp_transport_.flow_,
+        bundle_filter_);
+
+    audio_pipeline_->Init();
+  }
+
+  void SetBundleFilter(nsAutoPtr<MediaPipelineFilter> filter) {
+    bundle_filter_ = filter;
+  }
+
+  void UpdateFilter_s(
+      nsAutoPtr<MediaPipelineFilter> filter) {
+    audio_pipeline_->UpdateTransport_s(1,
+                                       audio_rtp_transport_.flow_,
+                                       audio_rtcp_transport_.flow_,
+                                       filter);
+  }
+
+ private:
+  nsAutoPtr<MediaPipelineFilter> bundle_filter_;
+};
+
+
+class MediaPipelineTest : public ::testing::Test {
+ public:
+  ~MediaPipelineTest() {
+    p1_.Stop();
+    p2_.Stop();
+    p1_.Shutdown();
+    p2_.Shutdown();
+  }
+
+  // Setup transport.
+  void InitTransports(bool aIsRtcpMux) {
+    // RTP, p1_ is server, p2_ is client
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnableNM(&TestAgent::ConnectRtp, &p2_, &p1_));
+
+    // Create RTCP flows separately if we are not muxing them.
+    if(!aIsRtcpMux) {
+      // RTCP, p1_ is server, p2_ is client
+      mozilla::SyncRunnable::DispatchToThread(
+        test_utils->sts_target(),
+        WrapRunnableNM(&TestAgent::ConnectRtcp, &p2_, &p1_));
+    }
+
+    // BUNDLE, p1_ is server, p2_ is client
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnableNM(&TestAgent::ConnectBundle, &p2_, &p1_));
+  }
+
+  // Verify RTP and RTCP
+  void TestAudioSend(bool aIsRtcpMux,
+                     nsAutoPtr<MediaPipelineFilter> initialFilter =
+                        nsAutoPtr<MediaPipelineFilter>(nullptr),
+                     nsAutoPtr<MediaPipelineFilter> refinedFilter =
+                        nsAutoPtr<MediaPipelineFilter>(nullptr),
+                     unsigned int ms_until_filter_update = 500,
+                     unsigned int ms_of_traffic_after_answer = 10000) {
+
+    bool bundle = !!(initialFilter);
+    // We do not support testing bundle without rtcp mux, since that doesn't
+    // make any sense.
+    ASSERT_FALSE(!aIsRtcpMux && bundle);
+
+    p2_.SetBundleFilter(initialFilter);
+
+    // Setup transport flows
+    InitTransports(aIsRtcpMux);
+
+    NS_DispatchToMainThread(
+      WrapRunnable(&p1_, &TestAgent::CreatePipelines_s, aIsRtcpMux),
+      NS_DISPATCH_SYNC);
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnable(&p2_, &TestAgent::CreatePipelines_s, aIsRtcpMux));
+
+    p2_.Start();
+    p1_.Start();
+
+    if (bundle) {
+      PR_Sleep(ms_until_filter_update);
+
+      // Leaving refinedFilter not set implies we want to just update with
+      // the other side's SSRC
+      if (!refinedFilter) {
+        refinedFilter = new MediaPipelineFilter;
+        // Might not be safe, strictly speaking.
+        refinedFilter->AddRemoteSSRC(p1_.GetLocalSSRC());
+      }
+
+      mozilla::SyncRunnable::DispatchToThread(
+          test_utils->sts_target(),
+          WrapRunnable(&p2_,
+                       &TestAgentReceive::UpdateFilter_s,
+                       refinedFilter));
+    }
+
+    // wait for some RTP/RTCP tx and rx to happen
+    PR_Sleep(ms_of_traffic_after_answer);
+
+    p1_.Stop();
+    p2_.Stop();
+
+    // wait for any packets in flight to arrive
+    PR_Sleep(100);
+
+    p1_.Shutdown();
+    p2_.Shutdown();
+
+    if (!bundle) {
+      // If we are filtering, allow the test-case to do this checking.
+      ASSERT_GE(p1_.GetAudioRtpCountSent(), 40);
+      ASSERT_EQ(p1_.GetAudioRtpCountReceived(), p2_.GetAudioRtpCountSent());
+      ASSERT_EQ(p1_.GetAudioRtpCountSent(), p2_.GetAudioRtpCountReceived());
+
+      // Calling ShutdownMedia_m on both pipelines does not stop the flow of
+      // RTCP. So, we might be off by one here.
+      ASSERT_LE(p2_.GetAudioRtcpCountReceived(), p1_.GetAudioRtcpCountSent());
+      ASSERT_GE(p2_.GetAudioRtcpCountReceived() + 1, p1_.GetAudioRtcpCountSent());
+    }
+
+  }
+
+  void TestAudioReceiverBundle(bool bundle_accepted,
+      nsAutoPtr<MediaPipelineFilter> initialFilter,
+      nsAutoPtr<MediaPipelineFilter> refinedFilter =
+          nsAutoPtr<MediaPipelineFilter>(nullptr),
+      unsigned int ms_until_answer = 500,
+      unsigned int ms_of_traffic_after_answer = 10000) {
+    TestAudioSend(true,
+                  initialFilter,
+                  refinedFilter,
+                  ms_until_answer,
+                  ms_of_traffic_after_answer);
+  }
+protected:
+  TestAgentSend p1_;
+  TestAgentReceive p2_;
+};
+
+class MediaPipelineFilterTest : public ::testing::Test {
+  public:
+    bool Filter(MediaPipelineFilter& filter,
+                int32_t correlator,
+                uint32_t ssrc,
+                uint8_t payload_type) {
+
+      webrtc::RTPHeader header;
+      header.ssrc = ssrc;
+      header.payloadType = payload_type;
+      return filter.Filter(header, correlator);
+    }
+};
+
+TEST_F(MediaPipelineFilterTest, TestConstruct) {
+  MediaPipelineFilter filter;
+}
+
+TEST_F(MediaPipelineFilterTest, TestDefault) {
+  MediaPipelineFilter filter;
+  ASSERT_FALSE(Filter(filter, 0, 233, 110));
+}
+
+TEST_F(MediaPipelineFilterTest, TestSSRCFilter) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(555);
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+  ASSERT_FALSE(Filter(filter, 0, 556, 110));
+}
+
+#define SSRC(ssrc) \
+  ((ssrc >> 24) & 0xFF), \
+  ((ssrc >> 16) & 0xFF), \
+  ((ssrc >> 8 ) & 0xFF), \
+  (ssrc         & 0xFF)
+
+#define REPORT_FRAGMENT(ssrc) \
+  SSRC(ssrc), \
+  0,0,0,0, \
+  0,0,0,0, \
+  0,0,0,0, \
+  0,0,0,0, \
+  0,0,0,0
+
+#define RTCP_TYPEINFO(num_rrs, type, size) \
+  0x80 + num_rrs, type, 0, size
+
+const unsigned char rtcp_sr_s16[] = {
+  // zero rrs, size 6 words
+  RTCP_TYPEINFO(0, MediaPipelineFilter::SENDER_REPORT_T, 6),
+  REPORT_FRAGMENT(16)
+};
+
+const unsigned char rtcp_sr_s16_r17[] = {
+  // one rr, size 12 words
+  RTCP_TYPEINFO(1, MediaPipelineFilter::SENDER_REPORT_T, 12),
+  REPORT_FRAGMENT(16),
+  REPORT_FRAGMENT(17)
+};
+
+const unsigned char unknown_type[] = {
+  RTCP_TYPEINFO(1, 222, 0)
+};
+
+TEST_F(MediaPipelineFilterTest, TestEmptyFilterReport0) {
+  MediaPipelineFilter filter;
+  ASSERT_FALSE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport0) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport0PTTruncated) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  const unsigned char data[] = {0x80};
+  ASSERT_FALSE(filter.FilterSenderReport(data, sizeof(data)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport0CountTruncated) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  const unsigned char data[] = {};
+  ASSERT_FALSE(filter.FilterSenderReport(data, sizeof(data)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport1SSRCTruncated) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  const unsigned char sr[] = {
+    RTCP_TYPEINFO(1, MediaPipelineFilter::SENDER_REPORT_T, 12),
+    REPORT_FRAGMENT(16),
+    0,0,0
+  };
+  ASSERT_TRUE(filter.FilterSenderReport(sr, sizeof(sr)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport1BigSSRC) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(0x01020304);
+  const unsigned char sr[] = {
+    RTCP_TYPEINFO(1, MediaPipelineFilter::SENDER_REPORT_T, 12),
+    SSRC(0x01020304),
+    REPORT_FRAGMENT(0x11121314)
+  };
+  ASSERT_TRUE(filter.FilterSenderReport(sr, sizeof(sr)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReportMatch) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16_r17,
+                                        sizeof(rtcp_sr_s16_r17)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReportNoMatch) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(17);
+  ASSERT_FALSE(filter.FilterSenderReport(rtcp_sr_s16_r17,
+                                         sizeof(rtcp_sr_s16_r17)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterUnknownRTCPType) {
+  MediaPipelineFilter filter;
+  ASSERT_FALSE(filter.FilterSenderReport(unknown_type, sizeof(unknown_type)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestCorrelatorFilter) {
+  MediaPipelineFilter filter;
+  filter.SetCorrelator(7777);
+  ASSERT_TRUE(Filter(filter, 7777, 16, 110));
+  ASSERT_FALSE(Filter(filter, 7778, 17, 110));
+  // This should also have resulted in the SSRC 16 being added to the filter
+  ASSERT_TRUE(Filter(filter, 0, 16, 110));
+  ASSERT_FALSE(Filter(filter, 0, 17, 110));
+
+  // rtcp_sr_s16 has 16 as an SSRC
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestPayloadTypeFilter) {
+  MediaPipelineFilter filter;
+  filter.AddUniquePT(110);
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+  ASSERT_FALSE(Filter(filter, 0, 556, 111));
+}
+
+TEST_F(MediaPipelineFilterTest, TestPayloadTypeFilterSSRCUpdate) {
+  MediaPipelineFilter filter;
+  filter.AddUniquePT(110);
+  ASSERT_TRUE(Filter(filter, 0, 16, 110));
+
+  // rtcp_sr_s16 has 16 as an SSRC
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestSSRCMovedWithCorrelator) {
+  MediaPipelineFilter filter;
+  filter.SetCorrelator(7777);
+  ASSERT_TRUE(Filter(filter, 7777, 555, 110));
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+  ASSERT_FALSE(Filter(filter, 7778, 555, 110));
+  ASSERT_FALSE(Filter(filter, 0, 555, 110));
+}
+
+TEST_F(MediaPipelineFilterTest, TestRemoteSDPNoSSRCs) {
+  // If the remote SDP doesn't have SSRCs, right now this is a no-op and
+  // there is no point of even incorporating a filter, but we make the
+  // behavior consistent to avoid confusion.
+  MediaPipelineFilter filter;
+  filter.SetCorrelator(7777);
+  filter.AddUniquePT(111);
+  ASSERT_TRUE(Filter(filter, 7777, 555, 110));
+
+  MediaPipelineFilter filter2;
+
+  filter.Update(filter2);
+
+  // Ensure that the old SSRC still works.
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+}
+
+TEST_F(MediaPipelineTest, DISABLED_TestAudioSendNoMux) {
+  TestAudioSend(false);
+}
+
+TEST_F(MediaPipelineTest, DISABLED_TestAudioSendMux) {
+  TestAudioSend(true);
+}
+
+TEST_F(MediaPipelineTest, TestAudioSendBundle) {
+  nsAutoPtr<MediaPipelineFilter> filter(new MediaPipelineFilter);
+  // These durations have to be _extremely_ long to have any assurance that
+  // some RTCP will be sent at all. This is because the first RTCP packet
+  // is sometimes sent before the transports are ready, which causes it to
+  // be dropped.
+  TestAudioReceiverBundle(true,
+                          filter,
+  // We do not specify the filter for the remote description, so it will be
+  // set to something sane after a short time.
+                          nsAutoPtr<MediaPipelineFilter>(),
+                          10000,
+                          10000);
+
+  // Some packets should have been dropped, but not all
+  ASSERT_GT(p1_.GetAudioRtpCountSent(), p2_.GetAudioRtpCountReceived());
+  ASSERT_GT(p2_.GetAudioRtpCountReceived(), 40);
+  ASSERT_GT(p1_.GetAudioRtcpCountSent(), 1);
+  ASSERT_GT(p1_.GetAudioRtcpCountSent(), p2_.GetAudioRtcpCountReceived());
+  ASSERT_GT(p2_.GetAudioRtcpCountReceived(), 0);
+}
+
+TEST_F(MediaPipelineTest, TestAudioSendEmptyBundleFilter) {
+  nsAutoPtr<MediaPipelineFilter> filter(new MediaPipelineFilter);
+  nsAutoPtr<MediaPipelineFilter> bad_answer_filter(new MediaPipelineFilter);
+  TestAudioReceiverBundle(true, filter, bad_answer_filter);
+  // Filter is empty, so should drop everything.
+  ASSERT_EQ(0, p2_.GetAudioRtpCountReceived());
+}
+
+}  // end namespace
+
+
+int main(int argc, char **argv) {
+  ScopedXPCOM xpcom("mediapipeline_unittest");
+  test_utils = new MtransportTestUtils();
+  // Start the tests
+  NSS_NoDB_Init(nullptr);
+  NSS_SetDomesticPolicy();
+  ::testing::InitGoogleTest(&argc, argv);
+
+  int rv = RUN_ALL_TESTS();
+  delete test_utils;
+  return rv;
+}
+
+
+