diff -r 000000000000 -r 6474c204b198 media/webrtc/signaling/test/FakeMediaStreamsImpl.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/media/webrtc/signaling/test/FakeMediaStreamsImpl.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,196 @@
+/* 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/. */
+
+#ifndef FAKE_MEDIA_STREAMIMPL_H_
+#define FAKE_MEDIA_STREAMIMPL_H_
+
+#include "FakeMediaStreams.h"
+
+#include "nspr.h"
+#include "nsError.h"
+
+void LogTime(AsyncLatencyLogger::LatencyLogIndex index, uint64_t b, int64_t c) {}
+void LogLatency(AsyncLatencyLogger::LatencyLogIndex index, uint64_t b, int64_t c) {}
+
+static const int AUDIO_BUFFER_SIZE = 1600;
+static const int NUM_CHANNELS      = 2;
+
+NS_IMPL_ISUPPORTS(Fake_DOMMediaStream, nsIDOMMediaStream)
+
+// Fake_SourceMediaStream
+nsresult Fake_SourceMediaStream::Start() {
+  mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+  if (!mTimer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mTimer->InitWithCallback(mPeriodic, 100, nsITimer::TYPE_REPEATING_SLACK);
+
+  return NS_OK;
+}
+
+nsresult Fake_SourceMediaStream::Stop() {
+  mozilla::MutexAutoLock lock(mMutex);
+  if (mTimer)
+    mTimer->Cancel();
+  mPeriodic->Detach();
+  return NS_OK;
+}
+
+void Fake_SourceMediaStream::Periodic() {
+  mozilla::MutexAutoLock lock(mMutex);
+  // Pull more audio-samples iff pulling is enabled
+  // and we are not asked by the signaling agent to stop
+  //pulling data.
+  if (mPullEnabled && !mStop) {
+    for (std::set<Fake_MediaStreamListener *>::iterator it =
+             mListeners.begin(); it != mListeners.end(); ++it) {
+      mDesiredTime += 10;
+      (*it)->NotifyPull(nullptr, mozilla::MillisecondsToMediaTime(mDesiredTime));
+    }
+  }
+}
+
+// Fake_MediaStreamBase
+nsresult Fake_MediaStreamBase::Start() {
+  mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+  if (!mTimer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mTimer->InitWithCallback(mPeriodic, 100, nsITimer::TYPE_REPEATING_SLACK);
+
+  return NS_OK;
+}
+
+nsresult Fake_MediaStreamBase::Stop() {
+  // Lock the mutex so that we know that after this
+  // has returned, periodic will not be firing again
+  // and so it's safe to destruct.
+  mozilla::MutexAutoLock lock(mMutex);
+  mTimer->Cancel();
+
+  return NS_OK;
+}
+
+// Fake_AudioStreamSource
+void Fake_AudioStreamSource::Periodic() {
+  mozilla::MutexAutoLock lock(mMutex);
+  //Are we asked to stop pumping audio samples ?
+  if(mStop) {
+    return;
+  }
+  //Generate Signed 16 Bit Audio samples
+  nsRefPtr<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<(1600*2); i++) {
+    //saw tooth audio sample
+    data[i] = ((mCount % 8) * 4000) - (7*4000)/2;
+    mCount++;
+  }
+
+  mozilla::AudioSegment segment;
+  nsAutoTArray<const int16_t *,1> channels;
+  channels.AppendElement(data);
+  segment.AppendFrames(samples.forget(), channels, AUDIO_BUFFER_SIZE);
+
+  for(std::set<Fake_MediaStreamListener *>::iterator it = mListeners.begin();
+       it != mListeners.end(); ++it) {
+    (*it)->NotifyQueuedTrackChanges(nullptr, // Graph
+                                    0, // TrackID
+                                    16000, // Rate (hz)
+                                    0, // Offset TODO(ekr@rtfm.com) fix
+                                    0, // ???
+                                    segment);
+  }
+}
+
+
+// Fake_MediaPeriodic
+NS_IMPL_ISUPPORTS(Fake_MediaPeriodic, nsITimerCallback)
+
+NS_IMETHODIMP
+Fake_MediaPeriodic::Notify(nsITimer *timer) {
+  if (mStream)
+    mStream->Periodic();
+  ++mCount;
+  return NS_OK;
+}
+
+
+#if 0
+#define WIDTH 320
+#define HEIGHT 240
+#define RATE USECS_PER_S
+#define USECS_PER_S 1000000
+#define FPS 10
+
+NS_IMETHODIMP
+Fake_VideoStreamSource::Notify(nsITimer* aTimer)
+{
+#if 0
+  mozilla::layers::BufferRecycleBin bin;
+
+  nsRefPtr<mozilla::layers::PlanarYCbCrImage> image = new
+    mozilla::layers::PlanarYCbCrImage(&bin);
+
+  const uint8_t lumaBpp = 8;
+  const uint8_t chromaBpp = 4;
+
+  int len = ((WIDTH * HEIGHT) * 3 / 2);
+  uint8_t* frame = (uint8_t*) PR_Malloc(len);
+  memset(frame, 0x80, len); // Gray
+
+  mozilla::layers::PlanarYCbCrData data;
+  data.mYChannel = frame;
+  data.mYSize = gfxIntSize(WIDTH, HEIGHT);
+  data.mYStride = WIDTH * lumaBpp / 8.0;
+  data.mCbCrStride = WIDTH * chromaBpp / 8.0;
+  data.mCbChannel = frame + HEIGHT * data.mYStride;
+  data.mCrChannel = data.mCbChannel + HEIGHT * data.mCbCrStride / 2;
+  data.mCbCrSize = gfxIntSize(WIDTH / 2, HEIGHT / 2);
+  data.mPicX = 0;
+  data.mPicY = 0;
+  data.mPicSize = gfxIntSize(WIDTH, HEIGHT);
+  data.mStereoMode = mozilla::layers::StereoMode::MONO;
+
+  mozilla::VideoSegment segment;
+  segment.AppendFrame(image.forget(), USECS_PER_S / FPS, gfxIntSize(WIDTH, HEIGHT));
+
+  // TODO(ekr@rtfm.com): are we leaking?
+#endif
+
+  return NS_OK;
+}
+
+
+#if 0
+// Fake up buffer recycle bin
+mozilla::layers::BufferRecycleBin::BufferRecycleBin() :
+ mLock("mozilla.layers.BufferRecycleBin.mLock") {
+}
+
+void mozilla::layers::BufferRecycleBin::RecycleBuffer(uint8_t* buffer, uint32_t size) {
+  PR_Free(buffer);
+}
+
+uint8_t *mozilla::layers::BufferRecycleBin::GetBuffer(uint32_t size) {
+  return (uint8_t *)PR_MALLOC(size);
+}
+
+// YCbCrImage constructor (from ImageLayers.cpp)
+mozilla::layers::PlanarYCbCrImage::PlanarYCbCrImage(BufferRecycleBin *aRecycleBin)
+  : Image(nsnull, ImageFormat::PLANAR_YCBCR)
+  , mBufferSize(0)
+  , mRecycleBin(aRecycleBin)
+{
+}
+
+
+#endif
+#endif
+
+
+#endif