rename from media/webrtc/signaling/test/mediapipeline_unittest.cpp
rename to media/webrtc/signaling/gtest/mediapipeline_unittest.cpp
--- a/media/webrtc/signaling/test/mediapipeline_unittest.cpp
+++ b/media/webrtc/signaling/gtest/mediapipeline_unittest.cpp
@@ -1,62 +1,171 @@
 /* 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 "DOMMediaStream.h"
+#include "mozilla/Mutex.h"
 #include "mozilla/RefPtr.h"
-#include "FakeMediaStreams.h"
-#include "FakeMediaStreamsImpl.h"
-#include "FakeLogging.h"
-#include "MediaConduitErrors.h"
-#include "MediaConduitInterface.h"
+#include "MediaEngineDefault.h"
 #include "MediaPipeline.h"
 #include "MediaPipelineFilter.h"
-#include "runnable_utils.h"
+#include "MediaStreamGraph.h"
+#include "MediaStreamListener.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/include/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 FakeSourceMediaStream : public mozilla::SourceMediaStream {
+
+public:
+
+  virtual ~FakeSourceMediaStream() override
+  {
+    mMainThreadDestroyed = true;
+  }
+
+  virtual bool AppendToTrack(TrackID aID, MediaSegment* aSegment, MediaSegment *aRawSegment = nullptr) override
+  {
+    return true;
+  }
+};
+
+class FakeMediaStreamTrackSource : public mozilla::dom::MediaStreamTrackSource {
+
+public:
+
+  FakeMediaStreamTrackSource()
+    : MediaStreamTrackSource(nullptr, nsString())
+  {
+  }
+
+  virtual mozilla::dom::MediaSourceEnum GetMediaSource() const override
+  {
+    return mozilla::dom::MediaSourceEnum::Microphone;
+  }
+
+  virtual void Stop() override
+  {
+  }
+
+};
+
+class FakeMediaStreamTrack : public mozilla::dom::MediaStreamTrack {
+
+public:
+
+  FakeMediaStreamTrack()
+    : MediaStreamTrack(new DOMMediaStream(nullptr, nullptr), 0, 1,
+                       new FakeMediaStreamTrackSource())
+    , mMutex("Fake MediaStreamTrack")
+    , mStop(false)
+    , mCount(0)
+  {
+    mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+    mTimer->SetTarget(test_utils->sts_target());
+    mTimer->InitWithFuncCallback(FakeMediaStreamTrackGenerateData, this, 20,
+                                            nsITimer::TYPE_REPEATING_SLACK);
+
+  }
+
+  void Stop()
+  {
+    mozilla::MutexAutoLock lock(mMutex);
+    mStop = true;
+    mTimer->Cancel();
+  }
+
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override
+  {
+    return nullptr;
+  }
+
+  virtual void GetKind(nsAString& aKind) override
+  {
+  }
+
+  virtual void AddListener(MediaStreamTrackListener* aListener) override
+  {
+    mozilla::MutexAutoLock lock(mMutex);
+    mListeners.push_back(aListener);
+  }
+
+  virtual void AddDirectListener(DirectMediaStreamTrackListener *aListener) override
+
+  {
+  }
+
+  virtual already_AddRefed<MediaStreamTrack> CloneInternal(DOMMediaStream* aOwningStream, TrackID aTrackID) override
+  {
+    return RefPtr<MediaStreamTrack>(new FakeMediaStreamTrack).forget();
+  }
+
+  private:
+    std::vector<MediaStreamTrackListener*> mListeners;
+    mozilla::Mutex mMutex;
+    bool mStop;
+    nsCOMPtr<nsITimer> mTimer;
+    int mCount;
+
+    static void FakeMediaStreamTrackGenerateData(nsITimer* timer, void* closure)
+    {
+      auto mst = static_cast<FakeMediaStreamTrack*>(closure);
+      const int AUDIO_BUFFER_SIZE = 1600;
+      const int NUM_CHANNELS      = 2;
+
+      mozilla::MutexAutoLock lock(mst->mMutex);
+      if (mst->mStop) {
+        return;
+      }
+
+      RefPtr<mozilla::SharedBuffer> samples =
+        mozilla::SharedBuffer::Create(AUDIO_BUFFER_SIZE * NUM_CHANNELS * sizeof(int16_t));
+      int16_t* data = reinterpret_cast<int16_t *>(samples->Data());
+      for(int i=0; i<(AUDIO_BUFFER_SIZE * NUM_CHANNELS); i++) {
+        //saw tooth audio sample
+        data[i] = ((mst->mCount % 8) * 4000) - (7*4000)/2;
+        mst->mCount++;
+      }
+
+      mozilla::AudioSegment segment;
+      AutoTArray<const int16_t *,1> channels;
+      channels.AppendElement(data);
+      segment.AppendFrames(samples.forget(),
+                           channels,
+                           AUDIO_BUFFER_SIZE,
+                           PRINCIPAL_HANDLE_NONE);
+
+      for (auto& listener: mst->mListeners) {
+        listener->NotifyQueuedChanges(nullptr, 0, segment);
+      }
+    }
+};
+
 class TransportInfo {
  public:
   TransportInfo() :
     flow_(nullptr),
     loopback_(nullptr),
     dtls_(nullptr) {}
 
   static void InitAndConnect(TransportInfo &client, TransportInfo &server) {
@@ -134,17 +243,16 @@ class TransportInfo {
   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_);
   }
 
@@ -156,29 +264,20 @@ class TestAgent {
   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();
 
@@ -193,32 +292,34 @@ class TestAgent {
     bundle_transport_.Shutdown();
     if (audio_pipeline_)
       audio_pipeline_->DetachTransport_s();
   }
 
   void Shutdown() {
     if (audio_pipeline_)
       audio_pipeline_->ShutdownMedia_m();
+    if (media_stream_track_)
+      media_stream_track_->Stop();
 
     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;
+    std::vector<uint32_t> res;
+    res = audio_conduit_->GetLocalSSRCs();
+    return res.size() > 0 ? res[0] : 0;
   }
 
   int GetAudioRtpCountSent() {
     return audio_pipeline_->rtp_packets_sent();
   }
 
   int GetAudioRtpCountReceived() {
     return audio_pipeline_->rtp_packets_received();
@@ -230,38 +331,31 @@ class TestAgent {
 
   int GetAudioRtcpCountReceived() {
     return audio_pipeline_->rtcp_packets_received();
   }
 
  protected:
   mozilla::AudioCodecConfig audio_config_;
   RefPtr<mozilla::MediaSessionConduit> audio_conduit_;
-  RefPtr<DOMMediaStream> audio_;
+  RefPtr<FakeMediaStreamTrack> media_stream_track_;
   // 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) {
@@ -271,21 +365,23 @@ class TestAgentSend : public TestAgent {
     RefPtr<TransportFlow> rtp(audio_rtp_transport_.flow_);
     RefPtr<TransportFlow> rtcp(audio_rtcp_transport_.flow_);
 
     if (use_bundle_) {
       rtp = bundle_transport_.flow_;
       rtcp = nullptr;
     }
 
+    media_stream_track_ = new FakeMediaStreamTrack();
+
     audio_pipeline_ = new mozilla::MediaPipelineTransmit(
         test_pc,
         nullptr,
         test_utils->sts_target(),
-        tracks[0],
+        media_stream_track_.get(),
         "audio_track_fake_uuid",
         1,
         audio_conduit_,
         rtp,
         rtcp,
         nsAutoPtr<MediaPipelineFilter>());
 
     audio_pipeline_->Init();
@@ -298,25 +394,16 @@ class TestAgentSend : public TestAgent {
  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);
 
@@ -325,17 +412,17 @@ class TestAgentReceive : public TestAgen
     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,
+        new FakeSourceMediaStream(), "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();
   }
 
@@ -360,16 +447,22 @@ class MediaPipelineTest : public ::testi
  public:
   ~MediaPipelineTest() {
     p1_.Stop();
     p2_.Stop();
     p1_.Shutdown();
     p2_.Shutdown();
   }
 
+  static void SetUpTestCase() {
+    test_utils = new MtransportTestUtils();
+    NSS_NoDB_Init(nullptr);
+    NSS_SetDomesticPolicy();
+  }
+
   // 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.
@@ -404,19 +497,19 @@ class MediaPipelineTest : public ::testi
 
     // 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));
+    NS_DispatchToMainThread(
+      WrapRunnable(&p2_, &TestAgent::CreatePipelines_s, aIsRtcpMux),
+      NS_DISPATCH_SYNC);
 
     p2_.Start();
     p1_.Start();
 
     if (bundle) {
       PR_Sleep(ms_until_filter_update);
 
       // Leaving refinedFilter not set implies we want to just update with
@@ -696,25 +789,8 @@ TEST_F(MediaPipelineTest, TestAudioSendE
   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;
-}
-
-
-

--- a/media/webrtc/signaling/gtest/moz.build
+++ b/media/webrtc/signaling/gtest/moz.build
@@ -2,26 +2,33 @@
 # vim: set filetype=python:
 # 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/.
 
 # TODO: bug 1172551 - get these tests working on iOS
 if CONFIG['OS_TARGET'] != 'WINNT' and CONFIG['MOZ_WIDGET_TOOLKIT'] != 'gonk' and CONFIG['MOZ_WIDGET_TOOLKIT'] != 'uikit':
     LOCAL_INCLUDES += [
+      '/dom/media',
       '/ipc/chromium/src',
       '/media/mtransport',
+      '/media/mtransport/test',
+      '/media/mtransport/third_party/nrappkit/src/registry',
       '/media/webrtc/',
       '/media/webrtc/signaling/src/common/time_profiling',
+      '/media/webrtc/signaling/src/media-conduit',
+      '/media/webrtc/signaling/src/mediapipeline',
       '/media/webrtc/signaling/src/peerconnection',
+      '/media/webrtc/trunk',
     ]
 
     SOURCES += [
         'jsep_session_unittest.cpp',
         'jsep_track_unittest.cpp',
+        'mediapipeline_unittest.cpp',
         'sdp_unittests.cpp',
     ]
 
     FINAL_LIBRARY = 'xul-gtest'
 
 if CONFIG['GNU_CXX']:
     CXXFLAGS += ['-Wno-error=shadow']