Add m-esr52 at 52.6.0

46 files changed, 7362 insertions, 0 deletions

diff --git a/dom/media/gtest/Cargo.toml b/dom/media/gtest/Cargo.toml
new file mode 100644
index 000000000..a55f8fb68
--- /dev/null
+++ b/dom/media/gtest/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "mp4parse-gtest"
+version = "0.1.0"
+authors = ["nobody@mozilla.org"]
+
+[lib]
+path = "hello.rs"
diff --git a/dom/media/gtest/GMPTestMonitor.h b/dom/media/gtest/GMPTestMonitor.h
new file mode 100644
index 000000000..8ce6f8ddd
--- /dev/null
+++ b/dom/media/gtest/GMPTestMonitor.h
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "nsThreadUtils.h"
+
+#ifndef __GMPTestMonitor_h__
+#define __GMPTestMonitor_h__
+
+class GMPTestMonitor
+{
+public:
+  GMPTestMonitor()
+    : mFinished(false)
+  {
+  }
+
+  void AwaitFinished()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    while (!mFinished) {
+      NS_ProcessNextEvent(nullptr, true);
+    }
+    mFinished = false;
+  }
+
+private:
+  void MarkFinished()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    mFinished = true;
+  }
+
+public:
+  void SetFinished()
+  {
+    NS_DispatchToMainThread(mozilla::NewNonOwningRunnableMethod(this,
+                                                                &GMPTestMonitor::MarkFinished));
+  }
+
+private:
+  bool mFinished;
+};
+
+#endif // __GMPTestMonitor_h__
diff --git a/dom/media/gtest/MockMediaDecoderOwner.h b/dom/media/gtest/MockMediaDecoderOwner.h
new file mode 100644
index 000000000..324f18141
--- /dev/null
+++ b/dom/media/gtest/MockMediaDecoderOwner.h
@@ -0,0 +1,54 @@
+/* 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 MOCK_MEDIA_DECODER_OWNER_H_
+#define MOCK_MEDIA_DECODER_OWNER_H_
+
+#include "MediaDecoderOwner.h"
+#include "nsAutoPtr.h"
+
+namespace mozilla
+{
+
+class MockMediaDecoderOwner : public MediaDecoderOwner
+{
+public:
+  nsresult DispatchAsyncEvent(const nsAString& aName) override
+  {
+    return NS_OK;
+  }
+  void FireTimeUpdate(bool aPeriodic) override {}
+  bool GetPaused() override { return false; }
+  void MetadataLoaded(const MediaInfo* aInfo,
+                      nsAutoPtr<const MetadataTags> aTags) override
+  {
+  }
+  void NetworkError() override {}
+  void DecodeError(const MediaResult& aError) override {}
+  bool HasError() const override { return false; }
+  void LoadAborted() override {}
+  void PlaybackEnded() override {}
+  void SeekStarted() override {}
+  void SeekCompleted() override {}
+  void DownloadProgressed() override {}
+  void UpdateReadyState() override {}
+  void FirstFrameLoaded() override {}
+  void DispatchEncrypted(const nsTArray<uint8_t>& aInitData,
+                         const nsAString& aInitDataType) override {}
+  bool IsActive() const override { return true; }
+  bool IsHidden() const override { return false; }
+  void DownloadSuspended() override {}
+  void DownloadResumed(bool aForceNetworkLoading) override {}
+  void NotifySuspendedByCache(bool aIsSuspended) override {}
+  void NotifyDecoderPrincipalChanged() override {}
+  VideoFrameContainer* GetVideoFrameContainer() override
+  {
+    return nullptr;
+  }
+  void SetAudibleState(bool aAudible) override {}
+  void NotifyXPCOMShutdown() override {}
+};
+}
+
+#endif
diff --git a/dom/media/gtest/MockMediaResource.cpp b/dom/media/gtest/MockMediaResource.cpp
new file mode 100644
index 000000000..4e75f8d9d
--- /dev/null
+++ b/dom/media/gtest/MockMediaResource.cpp
@@ -0,0 +1,116 @@
+/* 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/. */
+
+#include "MockMediaResource.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+namespace mozilla
+{
+
+MockMediaResource::MockMediaResource(const char* aFileName, const nsACString& aContentType)
+  : mFileHandle(nullptr)
+  , mFileName(aFileName)
+  , mContentType(aContentType)
+{
+}
+
+nsresult
+MockMediaResource::Open(nsIStreamListener** aStreamListener)
+{
+  mFileHandle = fopen(mFileName, "rb");
+  if (mFileHandle == nullptr) {
+    printf_stderr("Can't open %s\n", mFileName);
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+MockMediaResource::~MockMediaResource()
+{
+  if (mFileHandle != nullptr) {
+    fclose(mFileHandle);
+  }
+}
+
+nsresult
+MockMediaResource::ReadAt(int64_t aOffset, char* aBuffer, uint32_t aCount,
+                          uint32_t* aBytes)
+{
+  if (mFileHandle == nullptr) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Make it fail if we're re-entrant
+  if (mEntry++) {
+    MOZ_ASSERT(false);
+    return NS_ERROR_FAILURE;
+  }
+
+  fseek(mFileHandle, aOffset, SEEK_SET);
+  size_t objectsRead = fread(aBuffer, aCount, 1, mFileHandle);
+  *aBytes = objectsRead == 1 ? aCount : 0;
+
+  mEntry--;
+
+  return ferror(mFileHandle) ? NS_ERROR_FAILURE : NS_OK;
+}
+
+int64_t
+MockMediaResource::GetLength()
+{
+  if (mFileHandle == nullptr) {
+    return -1;
+  }
+  fseek(mFileHandle, 0, SEEK_END);
+  return ftell(mFileHandle);
+}
+
+void
+MockMediaResource::MockClearBufferedRanges()
+{
+  mRanges.Clear();
+}
+
+void
+MockMediaResource::MockAddBufferedRange(int64_t aStart, int64_t aEnd)
+{
+  mRanges += MediaByteRange(aStart, aEnd);
+}
+
+int64_t
+MockMediaResource::GetNextCachedData(int64_t aOffset)
+{
+  if (!aOffset) {
+    return mRanges.Length() ? mRanges[0].mStart : -1;
+  }
+  for (size_t i = 0; i < mRanges.Length(); i++) {
+    if (aOffset == mRanges[i].mStart) {
+      ++i;
+      return i < mRanges.Length() ? mRanges[i].mStart : -1;
+    }
+  }
+  return -1;
+}
+
+int64_t
+MockMediaResource::GetCachedDataEnd(int64_t aOffset)
+{
+  for (size_t i = 0; i < mRanges.Length(); i++) {
+    if (aOffset == mRanges[i].mStart) {
+      return mRanges[i].mEnd;
+    }
+  }
+  return -1;
+}
+
+nsresult
+MockMediaResource::GetCachedRanges(MediaByteRangeSet& aRanges)
+{
+  aRanges = mRanges;
+  return NS_OK;
+}
+
+} // namespace mozilla
diff --git a/dom/media/gtest/MockMediaResource.h b/dom/media/gtest/MockMediaResource.h
new file mode 100644
index 000000000..129ba1b72
--- /dev/null
+++ b/dom/media/gtest/MockMediaResource.h
@@ -0,0 +1,83 @@
+/* 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 MOCK_MEDIA_RESOURCE_H_
+#define MOCK_MEDIA_RESOURCE_H_
+
+#include "MediaResource.h"
+#include "nsTArray.h"
+#include "mozilla/Atomics.h"
+
+namespace mozilla
+{
+
+class MockMediaResource : public MediaResource
+{
+public:
+  explicit MockMediaResource(const char* aFileName, const nsACString& aMimeType = NS_LITERAL_CSTRING("video/mp4"));
+  nsIURI* URI() const override { return nullptr; }
+  nsresult Close() override { return NS_OK; }
+  void Suspend(bool aCloseImmediately) override {}
+  void Resume() override {}
+  already_AddRefed<nsIPrincipal> GetCurrentPrincipal() override
+  {
+    return nullptr;
+  }
+  bool CanClone() override { return false; }
+  already_AddRefed<MediaResource> CloneData(MediaResourceCallback*)
+    override
+  {
+    return nullptr;
+  }
+  void SetReadMode(MediaCacheStream::ReadMode aMode) override {}
+  void SetPlaybackRate(uint32_t aBytesPerSecond) override {}
+  nsresult ReadAt(int64_t aOffset, char* aBuffer, uint32_t aCount,
+                  uint32_t* aBytes) override;
+  int64_t Tell() override { return 0; }
+  void Pin() override {}
+  void Unpin() override {}
+  double GetDownloadRate(bool* aIsReliable) override { return 0; }
+  int64_t GetLength() override;
+  int64_t GetNextCachedData(int64_t aOffset) override;
+  int64_t GetCachedDataEnd(int64_t aOffset) override;
+  bool IsDataCachedToEndOfResource(int64_t aOffset) override
+  {
+    return false;
+  }
+  bool IsSuspendedByCache() override { return false; }
+  bool IsSuspended() override { return false; }
+  nsresult ReadFromCache(char* aBuffer, int64_t aOffset,
+                         uint32_t aCount) override
+  {
+    uint32_t bytesRead = 0;
+    nsresult rv = ReadAt(aOffset, aBuffer, aCount, &bytesRead);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return bytesRead == aCount ? NS_OK : NS_ERROR_FAILURE;
+  }
+
+  bool IsTransportSeekable() override { return true; }
+  nsresult Open(nsIStreamListener** aStreamListener) override;
+  nsresult GetCachedRanges(MediaByteRangeSet& aRanges) override;
+  const nsCString& GetContentType() const override
+  {
+    return mContentType;
+  }
+
+  void MockClearBufferedRanges();
+  void MockAddBufferedRange(int64_t aStart, int64_t aEnd);
+
+protected:
+  virtual ~MockMediaResource();
+
+private:
+  FILE* mFileHandle;
+  const char* mFileName;
+  MediaByteRangeSet mRanges;
+  Atomic<int> mEntry;
+  const nsCString mContentType;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/dom/media/gtest/TestAudioBuffers.cpp b/dom/media/gtest/TestAudioBuffers.cpp
new file mode 100644
index 000000000..b03886cec
--- /dev/null
+++ b/dom/media/gtest/TestAudioBuffers.cpp
@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include <stdint.h>
+#include "AudioBufferUtils.h"
+#include "gtest/gtest.h"
+
+const uint32_t FRAMES = 256;
+const uint32_t CHANNELS = 2;
+const uint32_t SAMPLES = CHANNELS * FRAMES;
+
+TEST(AudioBuffers, Test)
+{
+  mozilla::AudioCallbackBufferWrapper<float, CHANNELS> mBuffer;
+  mozilla::SpillBuffer<float, 128, CHANNELS> b;
+  float fromCallback[SAMPLES];
+  float other[SAMPLES];
+
+  for (uint32_t i = 0; i < SAMPLES; i++) {
+    other[i] = 1.0;
+    fromCallback[i] = 0.0;
+  }
+
+  // Set the buffer in the wrapper from the callback
+  mBuffer.SetBuffer(fromCallback, FRAMES);
+
+  // Fill the SpillBuffer with data.
+  ASSERT_TRUE(b.Fill(other, 15) == 15);
+  ASSERT_TRUE(b.Fill(other, 17) == 17);
+  for (uint32_t i = 0; i < 32 * CHANNELS; i++) {
+    other[i] = 0.0;
+  }
+
+  // Empty it in the AudioCallbackBufferWrapper
+  ASSERT_TRUE(b.Empty(mBuffer) == 32);
+
+  // Check available return something reasonnable
+  ASSERT_TRUE(mBuffer.Available() == FRAMES - 32);
+
+  // Fill the buffer with the rest of the data
+  mBuffer.WriteFrames(other + 32 * CHANNELS, FRAMES - 32);
+
+  // Check the buffer is now full
+  ASSERT_TRUE(mBuffer.Available() == 0);
+
+  for (uint32_t i = 0 ; i < SAMPLES; i++) {
+    ASSERT_TRUE(fromCallback[i] == 1.0) <<
+      "Difference at " << i << " (" << fromCallback[i] << " != " << 1.0 <<
+      ")\n";
+  }
+
+  ASSERT_TRUE(b.Fill(other, FRAMES) == 128);
+  ASSERT_TRUE(b.Fill(other, FRAMES) == 0);
+  ASSERT_TRUE(b.Empty(mBuffer) == 0);
+}
diff --git a/dom/media/gtest/TestAudioCompactor.cpp b/dom/media/gtest/TestAudioCompactor.cpp
new file mode 100644
index 000000000..9a28254b3
--- /dev/null
+++ b/dom/media/gtest/TestAudioCompactor.cpp
@@ -0,0 +1,145 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+#include "gtest/gtest.h"
+#include "AudioCompactor.h"
+#include "MediaDecoderReader.h"
+
+using mozilla::AudioCompactor;
+using mozilla::AudioData;
+using mozilla::AudioDataValue;
+using mozilla::MediaDecoderReader;
+using mozilla::MediaQueue;
+
+class MemoryFunctor : public nsDequeFunctor {
+public:
+  MemoryFunctor() : mSize(0) {}
+  MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf);
+
+  void* operator()(void* aObject) override {
+    const AudioData* audioData = static_cast<const AudioData*>(aObject);
+    mSize += audioData->SizeOfIncludingThis(MallocSizeOf);
+    return nullptr;
+  }
+
+  size_t mSize;
+};
+
+class TestCopy
+{
+public:
+  TestCopy(uint32_t aFrames, uint32_t aChannels,
+           uint32_t &aCallCount, uint32_t &aFrameCount)
+    : mFrames(aFrames)
+    , mChannels(aChannels)
+    , mCallCount(aCallCount)
+    , mFrameCount(aFrameCount)
+  { }
+
+  uint32_t operator()(AudioDataValue *aBuffer, uint32_t aSamples)
+  {
+    mCallCount += 1;
+    uint32_t frames = std::min(mFrames - mFrameCount, aSamples / mChannels);
+    mFrameCount += frames;
+    return frames;
+  }
+
+private:
+  const uint32_t mFrames;
+  const uint32_t mChannels;
+  uint32_t &mCallCount;
+  uint32_t &mFrameCount;
+};
+
+static void TestAudioCompactor(size_t aBytes)
+{
+  MediaQueue<AudioData> queue;
+  AudioCompactor compactor(queue);
+
+  uint64_t offset = 0;
+  uint64_t time = 0;
+  uint32_t sampleRate = 44000;
+  uint32_t channels = 2;
+  uint32_t frames = aBytes / (channels * sizeof(AudioDataValue));
+  size_t maxSlop = aBytes / AudioCompactor::MAX_SLOP_DIVISOR;
+
+  uint32_t callCount = 0;
+  uint32_t frameCount = 0;
+
+  compactor.Push(offset, time, sampleRate, frames, channels,
+                 TestCopy(frames, channels, callCount, frameCount));
+
+  EXPECT_GT(callCount, 0U) << "copy functor never called";
+  EXPECT_EQ(frames, frameCount) << "incorrect number of frames copied";
+
+  MemoryFunctor memoryFunc;
+  queue.LockedForEach(memoryFunc);
+  size_t allocSize = memoryFunc.mSize - (callCount * sizeof(AudioData));
+  size_t slop = allocSize - aBytes;
+  EXPECT_LE(slop, maxSlop) << "allowed too much allocation slop";
+}
+
+TEST(Media, AudioCompactor_4000)
+{
+  TestAudioCompactor(4000);
+}
+
+TEST(Media, AudioCompactor_4096)
+{
+  TestAudioCompactor(4096);
+}
+
+TEST(Media, AudioCompactor_5000)
+{
+  TestAudioCompactor(5000);
+}
+
+TEST(Media, AudioCompactor_5256)
+{
+  TestAudioCompactor(5256);
+}
+
+TEST(Media, AudioCompactor_NativeCopy)
+{
+  const uint32_t channels = 2;
+  const size_t srcBytes = 32;
+  const uint32_t srcSamples = srcBytes / sizeof(AudioDataValue);
+  const uint32_t srcFrames = srcSamples / channels;
+  uint8_t src[srcBytes];
+
+  for (uint32_t i = 0; i < srcBytes; ++i) {
+    src[i] = i;
+  }
+
+  AudioCompactor::NativeCopy copy(src, srcBytes, channels);
+
+  const uint32_t dstSamples = srcSamples * 2;
+  AudioDataValue dst[dstSamples];
+
+  const AudioDataValue notCopied = 0xffff;
+  for (uint32_t i = 0; i < dstSamples; ++i) {
+    dst[i] = notCopied;
+  }
+
+  const uint32_t copyCount = 8;
+  uint32_t copiedFrames = 0;
+  uint32_t nextSample = 0;
+  for (uint32_t i = 0; i < copyCount; ++i) {
+    uint32_t copySamples = dstSamples / copyCount;
+    copiedFrames += copy(dst + nextSample, copySamples);
+    nextSample += copySamples;
+  }
+
+  EXPECT_EQ(srcFrames, copiedFrames) << "copy exact number of source frames";
+
+  // Verify that the only the correct bytes were copied.
+  for (uint32_t i = 0; i < dstSamples; ++i) {
+    if (i < srcSamples) {
+      EXPECT_NE(notCopied, dst[i]) << "should have copied over these bytes";
+    } else {
+      EXPECT_EQ(notCopied, dst[i]) << "should not have copied over these bytes";
+    }
+  }
+}
diff --git a/dom/media/gtest/TestAudioMixer.cpp b/dom/media/gtest/TestAudioMixer.cpp
new file mode 100644
index 000000000..4e075a599
--- /dev/null
+++ b/dom/media/gtest/TestAudioMixer.cpp
@@ -0,0 +1,165 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "AudioMixer.h"
+#include "gtest/gtest.h"
+
+using mozilla::AudioDataValue;
+using mozilla::AudioSampleFormat;
+
+namespace audio_mixer {
+
+struct MixerConsumer : public mozilla::MixerCallbackReceiver
+{
+/* In this test, the different audio stream and channels are always created to
+ * cancel each other. */
+  void MixerCallback(AudioDataValue* aData, AudioSampleFormat aFormat, uint32_t aChannels, uint32_t aFrames, uint32_t aSampleRate)
+  {
+    bool silent = true;
+    for (uint32_t i = 0; i < aChannels * aFrames; i++) {
+      if (aData[i] != 0.0) {
+        if (aFormat == mozilla::AUDIO_FORMAT_S16) {
+          fprintf(stderr, "Sample at %d is not silent: %d\n", i, (short)aData[i]);
+        } else {
+          fprintf(stderr, "Sample at %d is not silent: %f\n", i, (float)aData[i]);
+        }
+        silent = false;
+      }
+    }
+    ASSERT_TRUE(silent);
+  }
+};
+
+/* Helper function to give us the maximum and minimum value that don't clip,
+ * for a given sample format (integer or floating-point). */
+template<typename T>
+T GetLowValue();
+
+template<typename T>
+T GetHighValue();
+
+template<>
+float GetLowValue<float>() {
+  return -1.0;
+}
+
+template<>
+short GetLowValue<short>() {
+  return -INT16_MAX;
+}
+
+template<>
+float GetHighValue<float>() {
+  return 1.0;
+}
+
+template<>
+short GetHighValue<short>() {
+  return INT16_MAX;
+}
+
+void FillBuffer(AudioDataValue* aBuffer, uint32_t aLength, AudioDataValue aValue)
+{
+  AudioDataValue* end = aBuffer + aLength;
+  while (aBuffer != end) {
+    *aBuffer++ = aValue;
+  }
+}
+
+TEST(AudioMixer, Test)
+{
+  const uint32_t CHANNEL_LENGTH = 256;
+  const uint32_t AUDIO_RATE = 44100;
+  MixerConsumer consumer;
+  AudioDataValue a[CHANNEL_LENGTH * 2];
+  AudioDataValue b[CHANNEL_LENGTH * 2];
+  FillBuffer(a, CHANNEL_LENGTH, GetLowValue<AudioDataValue>());
+  FillBuffer(a + CHANNEL_LENGTH, CHANNEL_LENGTH, GetHighValue<AudioDataValue>());
+  FillBuffer(b, CHANNEL_LENGTH, GetHighValue<AudioDataValue>());
+  FillBuffer(b + CHANNEL_LENGTH, CHANNEL_LENGTH, GetLowValue<AudioDataValue>());
+
+  {
+    int iterations = 2;
+    mozilla::AudioMixer mixer;
+    mixer.AddCallback(&consumer);
+
+    fprintf(stderr, "Test AudioMixer constant buffer length.\n");
+
+    while (iterations--) {
+      mixer.Mix(a, 2, CHANNEL_LENGTH, AUDIO_RATE);
+      mixer.Mix(b, 2, CHANNEL_LENGTH, AUDIO_RATE);
+      mixer.FinishMixing();
+    }
+  }
+
+  {
+    mozilla::AudioMixer mixer;
+    mixer.AddCallback(&consumer);
+
+    fprintf(stderr, "Test AudioMixer variable buffer length.\n");
+
+    FillBuffer(a, CHANNEL_LENGTH / 2, GetLowValue<AudioDataValue>());
+    FillBuffer(a + CHANNEL_LENGTH / 2, CHANNEL_LENGTH / 2, GetLowValue<AudioDataValue>());
+    FillBuffer(b, CHANNEL_LENGTH / 2, GetHighValue<AudioDataValue>());
+    FillBuffer(b + CHANNEL_LENGTH / 2, CHANNEL_LENGTH / 2, GetHighValue<AudioDataValue>());
+    mixer.Mix(a, 2, CHANNEL_LENGTH / 2, AUDIO_RATE);
+    mixer.Mix(b, 2, CHANNEL_LENGTH / 2, AUDIO_RATE);
+    mixer.FinishMixing();
+    FillBuffer(a, CHANNEL_LENGTH, GetLowValue<AudioDataValue>());
+    FillBuffer(a + CHANNEL_LENGTH, CHANNEL_LENGTH, GetHighValue<AudioDataValue>());
+    FillBuffer(b, CHANNEL_LENGTH, GetHighValue<AudioDataValue>());
+    FillBuffer(b + CHANNEL_LENGTH, CHANNEL_LENGTH, GetLowValue<AudioDataValue>());
+    mixer.Mix(a, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.FinishMixing();
+    FillBuffer(a, CHANNEL_LENGTH / 2, GetLowValue<AudioDataValue>());
+    FillBuffer(a + CHANNEL_LENGTH / 2, CHANNEL_LENGTH / 2, GetLowValue<AudioDataValue>());
+    FillBuffer(b, CHANNEL_LENGTH / 2, GetHighValue<AudioDataValue>());
+    FillBuffer(b + CHANNEL_LENGTH / 2, CHANNEL_LENGTH / 2, GetHighValue<AudioDataValue>());
+    mixer.Mix(a, 2, CHANNEL_LENGTH / 2, AUDIO_RATE);
+    mixer.Mix(b, 2, CHANNEL_LENGTH / 2, AUDIO_RATE);
+    mixer.FinishMixing();
+  }
+
+  FillBuffer(a, CHANNEL_LENGTH, GetLowValue<AudioDataValue>());
+  FillBuffer(b, CHANNEL_LENGTH, GetHighValue<AudioDataValue>());
+
+  {
+    mozilla::AudioMixer mixer;
+    mixer.AddCallback(&consumer);
+
+    fprintf(stderr, "Test AudioMixer variable channel count.\n");
+
+    mixer.Mix(a, 1, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 1, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.FinishMixing();
+    mixer.Mix(a, 1, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 1, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.FinishMixing();
+    mixer.Mix(a, 1, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 1, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.FinishMixing();
+  }
+
+  {
+    mozilla::AudioMixer mixer;
+    mixer.AddCallback(&consumer);
+    fprintf(stderr, "Test AudioMixer variable stream count.\n");
+
+    mixer.Mix(a, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.FinishMixing();
+    mixer.Mix(a, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(a, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.FinishMixing();
+    mixer.Mix(a, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.Mix(b, 2, CHANNEL_LENGTH, AUDIO_RATE);
+    mixer.FinishMixing();
+  }
+}
+
+} // namespace audio_mixer
diff --git a/dom/media/gtest/TestAudioPacketizer.cpp b/dom/media/gtest/TestAudioPacketizer.cpp
new file mode 100644
index 000000000..86615eb10
--- /dev/null
+++ b/dom/media/gtest/TestAudioPacketizer.cpp
@@ -0,0 +1,167 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include <stdint.h>
+#include <math.h>
+#include "../AudioPacketizer.h"
+#include "gtest/gtest.h"
+
+using namespace mozilla;
+
+template<typename T>
+class AutoBuffer
+{
+public:
+  explicit AutoBuffer(size_t aLength)
+  {
+    mStorage = new T[aLength];
+  }
+  ~AutoBuffer() {
+    delete [] mStorage;
+  }
+  T* Get() {
+    return mStorage;
+  }
+private:
+  T* mStorage;
+};
+
+int16_t Sequence(int16_t* aBuffer, uint32_t aSize, uint32_t aStart = 0)
+{
+  uint32_t i;
+  for (i = 0; i < aSize; i++) {
+    aBuffer[i] = aStart + i;
+  }
+  return aStart + i;
+}
+
+void IsSequence(int16_t* aBuffer, uint32_t aSize, uint32_t aStart = 0)
+{
+  for (uint32_t i = 0; i < aSize; i++) {
+    ASSERT_TRUE(aBuffer[i] == static_cast<int64_t>(aStart + i)) <<
+      "Buffer is not a sequence at offset " << i << std::endl;
+  }
+  // Buffer is a sequence.
+}
+
+void Zero(int16_t* aBuffer, uint32_t aSize)
+{
+  for (uint32_t i = 0; i < aSize; i++) {
+    ASSERT_TRUE(aBuffer[i] == 0) <<
+      "Buffer is not null at offset " << i << std::endl;
+  }
+}
+
+double sine(uint32_t aPhase) {
+  return sin(aPhase * 2 * M_PI * 440 / 44100);
+}
+
+TEST(AudioPacketizer, Test)
+{
+  for (int16_t channels = 1; channels < 2; channels++) {
+    // Test that the packetizer returns zero on underrun
+    {
+      AudioPacketizer<int16_t, int16_t> ap(441, channels);
+      for (int16_t i = 0; i < 10; i++) {
+        int16_t* out = ap.Output();
+        Zero(out, 441);
+        delete[] out;
+      }
+    }
+    // Simple test, with input/output buffer size aligned on the packet size,
+    // alternating Input and Output calls.
+    {
+      AudioPacketizer<int16_t, int16_t> ap(441, channels);
+      int16_t seqEnd = 0;
+      for (int16_t i = 0; i < 10; i++) {
+        AutoBuffer<int16_t> b(441 * channels);
+        int16_t prevEnd = seqEnd;
+        seqEnd = Sequence(b.Get(), channels * 441, prevEnd);
+        ap.Input(b.Get(), 441);
+        int16_t* out = ap.Output();
+        IsSequence(out, 441 * channels, prevEnd);
+        delete[] out;
+      }
+    }
+    // Simple test, with input/output buffer size aligned on the packet size,
+    // alternating two Input and Output calls.
+    {
+      AudioPacketizer<int16_t, int16_t> ap(441, channels);
+      int16_t seqEnd = 0;
+      for (int16_t i = 0; i < 10; i++) {
+        AutoBuffer<int16_t> b(441 * channels);
+        AutoBuffer<int16_t> b1(441 * channels);
+        int16_t prevEnd0 = seqEnd;
+        seqEnd = Sequence(b.Get(), 441 * channels, prevEnd0);
+        int16_t prevEnd1 = seqEnd;
+        seqEnd = Sequence(b1.Get(), 441 * channels, seqEnd);
+        ap.Input(b.Get(), 441);
+        ap.Input(b1.Get(), 441);
+        int16_t* out = ap.Output();
+        int16_t* out2 = ap.Output();
+        IsSequence(out, 441 * channels, prevEnd0);
+        IsSequence(out2, 441 * channels, prevEnd1);
+        delete[] out;
+        delete[] out2;
+      }
+    }
+    // Input/output buffer size not aligned on the packet size,
+    // alternating two Input and Output calls.
+    {
+      AudioPacketizer<int16_t, int16_t> ap(441, channels);
+      int16_t prevEnd = 0;
+      int16_t prevSeq = 0;
+      for (int16_t i = 0; i < 10; i++) {
+        AutoBuffer<int16_t> b(480 * channels);
+        AutoBuffer<int16_t> b1(480 * channels);
+        prevSeq = Sequence(b.Get(), 480 * channels, prevSeq);
+        prevSeq = Sequence(b1.Get(), 480 * channels, prevSeq);
+        ap.Input(b.Get(), 480);
+        ap.Input(b1.Get(), 480);
+        int16_t* out = ap.Output();
+        int16_t* out2 = ap.Output();
+        IsSequence(out, 441 * channels, prevEnd);
+        prevEnd += 441 * channels;
+        IsSequence(out2, 441 * channels, prevEnd);
+        prevEnd += 441 * channels;
+        delete[] out;
+        delete[] out2;
+      }
+      printf("Available: %d\n", ap.PacketsAvailable());
+    }
+
+    // "Real-life" test case: streaming a sine wave through a packetizer, and
+    // checking that we have the right output.
+    // 128 is, for example, the size of a Web Audio API block, and 441 is the
+    // size of a webrtc.org packet when the sample rate is 44100 (10ms)
+    {
+      AudioPacketizer<int16_t, int16_t> ap(441, channels);
+      AutoBuffer<int16_t> b(128 * channels);
+      uint32_t phase = 0;
+      uint32_t outPhase = 0;
+      for (int16_t i = 0; i < 1000; i++) {
+        for (int32_t j = 0; j < 128; j++) {
+          for (int32_t c = 0; c < channels; c++) {
+            // int16_t sinewave at 440Hz/44100Hz sample rate
+            b.Get()[j * channels + c] = (2 << 14) * sine(phase);
+          }
+          phase++;
+        }
+        ap.Input(b.Get(), 128);
+        while (ap.PacketsAvailable()) {
+          int16_t* packet = ap.Output();
+          for (uint32_t k = 0; k < ap.PacketSize(); k++) {
+            for (int32_t c = 0; c < channels; c++) {
+              ASSERT_TRUE(packet[k * channels + c] ==
+                          static_cast<int16_t>(((2 << 14) * sine(outPhase))));
+            }
+            outPhase++;
+          }
+          delete [] packet;
+        }
+      }
+    }
+  }
+}
diff --git a/dom/media/gtest/TestAudioSegment.cpp b/dom/media/gtest/TestAudioSegment.cpp
new file mode 100644
index 000000000..968b4b5a1
--- /dev/null
+++ b/dom/media/gtest/TestAudioSegment.cpp
@@ -0,0 +1,257 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "AudioSegment.h"
+#include <iostream>
+#include "gtest/gtest.h"
+
+using namespace mozilla;
+
+namespace audio_segment {
+
+/* Helper function to give us the maximum and minimum value that don't clip,
+ * for a given sample format (integer or floating-point). */
+template<typename T>
+T GetLowValue();
+
+template<typename T>
+T GetHighValue();
+
+template<typename T>
+T GetSilentValue();
+
+template<>
+float GetLowValue<float>() {
+  return -1.0;
+}
+
+template<>
+int16_t GetLowValue<short>() {
+  return -INT16_MAX;
+}
+
+template<>
+float GetHighValue<float>() {
+  return 1.0;
+}
+
+template<>
+int16_t GetHighValue<short>() {
+  return INT16_MAX;
+}
+
+template<>
+float GetSilentValue() {
+  return 0.0;
+}
+
+template<>
+int16_t GetSilentValue() {
+  return 0;
+}
+
+
+// Get an array of planar audio buffers that has the inverse of the index of the
+// channel (1-indexed) as samples.
+template<typename T>
+const T* const* GetPlanarChannelArray(size_t aChannels, size_t aSize)
+{
+  T** channels = new T*[aChannels];
+  for (size_t c = 0; c < aChannels; c++) {
+    channels[c] = new T[aSize];
+    for (size_t i = 0; i < aSize; i++) {
+      channels[c][i] = FloatToAudioSample<T>(1. / (c + 1));
+    }
+  }
+  return channels;
+}
+
+template<typename T>
+void DeletePlanarChannelsArray(const T* const* aArrays, size_t aChannels)
+{
+  for (size_t channel = 0; channel < aChannels; channel++) {
+    delete [] aArrays[channel];
+  }
+  delete [] aArrays;
+}
+
+template<typename T>
+T** GetPlanarArray(size_t aChannels, size_t aSize)
+{
+  T** channels = new T*[aChannels];
+  for (size_t c = 0; c < aChannels; c++) {
+    channels[c] = new T[aSize];
+    for (size_t i = 0; i < aSize; i++) {
+      channels[c][i] = 0.0f;
+    }
+  }
+  return channels;
+}
+
+template<typename T>
+void DeletePlanarArray(T** aArrays, size_t aChannels)
+{
+  for (size_t channel = 0; channel < aChannels; channel++) {
+    delete [] aArrays[channel];
+  }
+  delete [] aArrays;
+}
+
+// Get an array of audio samples that have the inverse of the index of the
+// channel (1-indexed) as samples.
+template<typename T>
+const T* GetInterleavedChannelArray(size_t aChannels, size_t aSize)
+{
+  size_t sampleCount = aChannels * aSize;
+  T* samples = new T[sampleCount];
+  for (size_t i = 0; i < sampleCount; i++) {
+    uint32_t channel = (i % aChannels) + 1;
+    samples[i] = FloatToAudioSample<T>(1. / channel);
+  }
+  return samples;
+}
+
+template<typename T>
+void DeleteInterleavedChannelArray(const T* aArray)
+{
+  delete [] aArray;
+}
+
+bool FuzzyEqual(float aLhs, float aRhs) {
+  return std::abs(aLhs - aRhs) < 0.01;
+}
+
+template<typename SrcT, typename DstT>
+void TestInterleaveAndConvert()
+{
+  size_t arraySize = 1024;
+  size_t maxChannels = 8; // 7.1
+  for (uint32_t channels = 1; channels < maxChannels; channels++) {
+    const SrcT* const* src = GetPlanarChannelArray<SrcT>(channels, arraySize);
+    DstT* dst = new DstT[channels * arraySize];
+
+    InterleaveAndConvertBuffer(src, arraySize, 1.0, channels, dst);
+
+    uint32_t channelIndex = 0;
+    for (size_t i = 0; i < arraySize * channels; i++) {
+      ASSERT_TRUE(FuzzyEqual(dst[i],
+                  FloatToAudioSample<DstT>(1. / (channelIndex + 1))));
+      channelIndex++;
+      channelIndex %= channels;
+    }
+
+    DeletePlanarChannelsArray(src, channels);
+    delete [] dst;
+  }
+}
+
+template<typename SrcT, typename DstT>
+void TestDeinterleaveAndConvert()
+{
+  size_t arraySize = 1024;
+  size_t maxChannels = 8; // 7.1
+  for (uint32_t channels = 1; channels < maxChannels; channels++) {
+    const SrcT* src = GetInterleavedChannelArray<SrcT>(channels, arraySize);
+    DstT** dst = GetPlanarArray<DstT>(channels, arraySize);
+
+    DeinterleaveAndConvertBuffer(src, arraySize, channels, dst);
+
+    for (size_t channel = 0; channel < channels; channel++) {
+      for (size_t i = 0; i < arraySize; i++) {
+        ASSERT_TRUE(FuzzyEqual(dst[channel][i],
+                    FloatToAudioSample<DstT>(1. / (channel + 1))));
+      }
+    }
+
+    DeleteInterleavedChannelArray(src);
+    DeletePlanarArray(dst, channels);
+  }
+}
+
+uint8_t gSilence[4096] = {0};
+
+template<typename T>
+T* SilentChannel()
+{
+  return reinterpret_cast<T*>(gSilence);
+}
+
+template<typename T>
+void TestUpmixStereo()
+{
+  size_t arraySize = 1024;
+  nsTArray<T*> channels;
+  nsTArray<const T*> channelsptr;
+
+  channels.SetLength(1);
+  channelsptr.SetLength(1);
+
+  channels[0] = new T[arraySize];
+
+  for (size_t i = 0; i < arraySize; i++) {
+    channels[0][i] = GetHighValue<T>();
+  }
+  channelsptr[0] = channels[0];
+
+  AudioChannelsUpMix(&channelsptr, 2, SilentChannel<T>());
+
+  for (size_t channel = 0; channel < 2; channel++) {
+    for (size_t i = 0; i < arraySize; i++) {
+      ASSERT_TRUE(channelsptr[channel][i] == GetHighValue<T>());
+    }
+  }
+  delete channels[0];
+}
+
+template<typename T>
+void TestDownmixStereo()
+{
+  const size_t arraySize = 1024;
+  nsTArray<const T*> inputptr;
+  nsTArray<T*> input;
+  T** output;
+
+  output = new T*[1];
+  output[0] = new T[arraySize];
+
+  input.SetLength(2);
+  inputptr.SetLength(2);
+
+  for (size_t channel = 0; channel < input.Length(); channel++) {
+    input[channel] = new T[arraySize];
+    for (size_t i = 0; i < arraySize; i++) {
+      input[channel][i] = channel == 0 ? GetLowValue<T>() : GetHighValue<T>();
+    }
+    inputptr[channel] = input[channel];
+  }
+
+  AudioChannelsDownMix(inputptr, output, 1, arraySize);
+
+  for (size_t i = 0; i < arraySize; i++) {
+    ASSERT_TRUE(output[0][i] == GetSilentValue<T>());
+    ASSERT_TRUE(output[0][i] == GetSilentValue<T>());
+  }
+
+  delete output[0];
+  delete output;
+}
+
+TEST(AudioSegment, Test)
+{
+  TestInterleaveAndConvert<float, float>();
+  TestInterleaveAndConvert<float, int16_t>();
+  TestInterleaveAndConvert<int16_t, float>();
+  TestInterleaveAndConvert<int16_t, int16_t>();
+  TestDeinterleaveAndConvert<float, float>();
+  TestDeinterleaveAndConvert<float, int16_t>();
+  TestDeinterleaveAndConvert<int16_t, float>();
+  TestDeinterleaveAndConvert<int16_t, int16_t>();
+  TestUpmixStereo<float>();
+  TestUpmixStereo<int16_t>();
+  TestDownmixStereo<float>();
+  TestDownmixStereo<int16_t>();
+}
+
+} // namespace audio_segment
diff --git a/dom/media/gtest/TestGMPCrossOrigin.cpp b/dom/media/gtest/TestGMPCrossOrigin.cpp
new file mode 100644
index 000000000..036282153
--- /dev/null
+++ b/dom/media/gtest/TestGMPCrossOrigin.cpp
@@ -0,0 +1,1552 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "nsAutoPtr.h"
+#include "nsIObserverService.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPtr.h"
+#include "GMPTestMonitor.h"
+#include "GMPVideoDecoderProxy.h"
+#include "GMPVideoEncoderProxy.h"
+#include "GMPDecryptorProxy.h"
+#include "GMPServiceParent.h"
+#include "MediaPrefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIFile.h"
+#include "nsISimpleEnumerator.h"
+#include "mozilla/Atomics.h"
+#include "nsNSSComponent.h"
+#include "mozilla/DebugOnly.h"
+#include "GMPDeviceBinding.h"
+#include "mozilla/dom/MediaKeyStatusMapBinding.h" // For MediaKeyStatus
+#include "mozilla/dom/MediaKeyMessageEventBinding.h" // For MediaKeyMessageType
+
+#if defined(XP_WIN)
+#include "mozilla/WindowsVersion.h"
+#endif
+
+using namespace std;
+
+using namespace mozilla;
+using namespace mozilla::gmp;
+
+struct GMPTestRunner
+{
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GMPTestRunner)
+
+  GMPTestRunner() { MediaPrefs::GetSingleton(); }
+  void DoTest(void (GMPTestRunner::*aTestMethod)(GMPTestMonitor&));
+  void RunTestGMPTestCodec1(GMPTestMonitor& aMonitor);
+  void RunTestGMPTestCodec2(GMPTestMonitor& aMonitor);
+  void RunTestGMPTestCodec3(GMPTestMonitor& aMonitor);
+  void RunTestGMPCrossOrigin1(GMPTestMonitor& aMonitor);
+  void RunTestGMPCrossOrigin2(GMPTestMonitor& aMonitor);
+  void RunTestGMPCrossOrigin3(GMPTestMonitor& aMonitor);
+  void RunTestGMPCrossOrigin4(GMPTestMonitor& aMonitor);
+
+private:
+  ~GMPTestRunner() { }
+};
+
+template<class T, class Base,
+         nsresult (NS_STDCALL GeckoMediaPluginService::*Getter)(GMPCrashHelper*,
+                                                                nsTArray<nsCString>*,
+                                                                const nsACString&,
+                                                                UniquePtr<Base>&&)>
+class RunTestGMPVideoCodec : public Base
+{
+public:
+  void Done(T* aGMP, GMPVideoHost* aHost) override
+  {
+    EXPECT_TRUE(aGMP);
+    EXPECT_TRUE(aHost);
+    if (aGMP) {
+      aGMP->Close();
+    }
+    mMonitor.SetFinished();
+  }
+
+  static void Run(GMPTestMonitor& aMonitor, const nsCString& aOrigin)
+  {
+    UniquePtr<GMPCallbackType> callback(new RunTestGMPVideoCodec(aMonitor));
+    Get(aOrigin, Move(callback));
+  }
+
+protected:
+  typedef T GMPCodecType;
+  typedef Base GMPCallbackType;
+
+  explicit RunTestGMPVideoCodec(GMPTestMonitor& aMonitor)
+    : mMonitor(aMonitor)
+  {
+  }
+
+  static nsresult Get(const nsACString& aNodeId, UniquePtr<Base>&& aCallback)
+  {
+    nsTArray<nsCString> tags;
+    tags.AppendElement(NS_LITERAL_CSTRING("h264"));
+    tags.AppendElement(NS_LITERAL_CSTRING("fake"));
+
+    RefPtr<GeckoMediaPluginService> service =
+      GeckoMediaPluginService::GetGeckoMediaPluginService();
+    return ((*service).*Getter)(nullptr, &tags, aNodeId, Move(aCallback));
+  }
+
+protected:
+  GMPTestMonitor& mMonitor;
+};
+
+typedef RunTestGMPVideoCodec<GMPVideoDecoderProxy,
+                             GetGMPVideoDecoderCallback,
+                             &GeckoMediaPluginService::GetGMPVideoDecoder>
+  RunTestGMPVideoDecoder;
+typedef RunTestGMPVideoCodec<GMPVideoEncoderProxy,
+                             GetGMPVideoEncoderCallback,
+                             &GeckoMediaPluginService::GetGMPVideoEncoder>
+  RunTestGMPVideoEncoder;
+
+void
+GMPTestRunner::RunTestGMPTestCodec1(GMPTestMonitor& aMonitor)
+{
+  RunTestGMPVideoDecoder::Run(aMonitor, NS_LITERAL_CSTRING("o"));
+}
+
+void
+GMPTestRunner::RunTestGMPTestCodec2(GMPTestMonitor& aMonitor)
+{
+  RunTestGMPVideoDecoder::Run(aMonitor, NS_LITERAL_CSTRING(""));
+}
+
+void
+GMPTestRunner::RunTestGMPTestCodec3(GMPTestMonitor& aMonitor)
+{
+  RunTestGMPVideoEncoder::Run(aMonitor, NS_LITERAL_CSTRING(""));
+}
+
+template<class Base>
+class RunTestGMPCrossOrigin : public Base
+{
+public:
+  void Done(typename Base::GMPCodecType* aGMP, GMPVideoHost* aHost) override
+  {
+    EXPECT_TRUE(aGMP);
+
+    UniquePtr<typename Base::GMPCallbackType> callback(
+      new Step2(Base::mMonitor, aGMP, mShouldBeEqual));
+    nsresult rv = Base::Get(mOrigin2, Move(callback));
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    if (NS_FAILED(rv)) {
+      Base::mMonitor.SetFinished();
+    }
+  }
+
+  static void Run(GMPTestMonitor& aMonitor, const nsCString& aOrigin1,
+                  const nsCString& aOrigin2)
+  {
+    UniquePtr<typename Base::GMPCallbackType> callback(
+      new RunTestGMPCrossOrigin<Base>(aMonitor, aOrigin1, aOrigin2));
+    nsresult rv = Base::Get(aOrigin1, Move(callback));
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    if (NS_FAILED(rv)) {
+      aMonitor.SetFinished();
+    }
+  }
+
+private:
+  RunTestGMPCrossOrigin(GMPTestMonitor& aMonitor, const nsCString& aOrigin1,
+                        const nsCString& aOrigin2)
+    : Base(aMonitor),
+      mGMP(nullptr),
+      mOrigin2(aOrigin2),
+      mShouldBeEqual(aOrigin1.Equals(aOrigin2))
+  {
+  }
+
+  class Step2 : public Base
+  {
+  public:
+    Step2(GMPTestMonitor& aMonitor,
+          typename Base::GMPCodecType* aGMP,
+          bool aShouldBeEqual)
+      : Base(aMonitor),
+        mGMP(aGMP),
+        mShouldBeEqual(aShouldBeEqual)
+    {
+    }
+    void Done(typename Base::GMPCodecType* aGMP, GMPVideoHost* aHost) override
+    {
+      EXPECT_TRUE(aGMP);
+      if (aGMP) {
+        EXPECT_TRUE(mGMP &&
+                    (mGMP->GetPluginId() == aGMP->GetPluginId()) == mShouldBeEqual);
+      }
+      if (mGMP) {
+        mGMP->Close();
+      }
+      Base::Done(aGMP, aHost);
+    }
+
+  private:
+    typename Base::GMPCodecType* mGMP;
+    bool mShouldBeEqual;
+  };
+
+  typename Base::GMPCodecType* mGMP;
+  nsCString mOrigin2;
+  bool mShouldBeEqual;
+};
+
+typedef RunTestGMPCrossOrigin<RunTestGMPVideoDecoder>
+  RunTestGMPVideoDecoderCrossOrigin;
+typedef RunTestGMPCrossOrigin<RunTestGMPVideoEncoder>
+  RunTestGMPVideoEncoderCrossOrigin;
+
+void
+GMPTestRunner::RunTestGMPCrossOrigin1(GMPTestMonitor& aMonitor)
+{
+  RunTestGMPVideoDecoderCrossOrigin::Run(
+    aMonitor, NS_LITERAL_CSTRING("origin1"), NS_LITERAL_CSTRING("origin2"));
+}
+
+void
+GMPTestRunner::RunTestGMPCrossOrigin2(GMPTestMonitor& aMonitor)
+{
+  RunTestGMPVideoEncoderCrossOrigin::Run(
+    aMonitor, NS_LITERAL_CSTRING("origin1"), NS_LITERAL_CSTRING("origin2"));
+}
+
+void
+GMPTestRunner::RunTestGMPCrossOrigin3(GMPTestMonitor& aMonitor)
+{
+  RunTestGMPVideoDecoderCrossOrigin::Run(
+    aMonitor, NS_LITERAL_CSTRING("origin1"), NS_LITERAL_CSTRING("origin1"));
+}
+
+void
+GMPTestRunner::RunTestGMPCrossOrigin4(GMPTestMonitor& aMonitor)
+{
+  RunTestGMPVideoEncoderCrossOrigin::Run(
+    aMonitor, NS_LITERAL_CSTRING("origin1"), NS_LITERAL_CSTRING("origin1"));
+}
+
+static already_AddRefed<nsIThread>
+GetGMPThread()
+{
+  RefPtr<GeckoMediaPluginService> service =
+    GeckoMediaPluginService::GetGeckoMediaPluginService();
+  nsCOMPtr<nsIThread> thread;
+  EXPECT_TRUE(NS_SUCCEEDED(service->GetThread(getter_AddRefs(thread))));
+  return thread.forget();
+}
+
+/**
+ * Enumerate files under |aPath| (non-recursive).
+ */
+template<typename T>
+static nsresult
+EnumerateDir(nsIFile* aPath, T&& aDirIter)
+{
+  nsCOMPtr<nsISimpleEnumerator> iter;
+  nsresult rv = aPath->GetDirectoryEntries(getter_AddRefs(iter));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  bool hasMore = false;
+  while (NS_SUCCEEDED(iter->HasMoreElements(&hasMore)) && hasMore) {
+    nsCOMPtr<nsISupports> supports;
+    rv = iter->GetNext(getter_AddRefs(supports));
+    if (NS_FAILED(rv)) {
+      continue;
+    }
+
+    nsCOMPtr<nsIFile> entry(do_QueryInterface(supports, &rv));
+    if (NS_FAILED(rv)) {
+      continue;
+    }
+
+    aDirIter(entry);
+  }
+  return NS_OK;
+}
+
+/**
+ * Enumerate files under $profileDir/gmp/$platform/gmp-fake/$aDir/ (non-recursive).
+ */
+template<typename T>
+static nsresult
+EnumerateGMPStorageDir(const nsACString& aDir, T&& aDirIter)
+{
+  RefPtr<GeckoMediaPluginServiceParent> service =
+    GeckoMediaPluginServiceParent::GetSingleton();
+  MOZ_ASSERT(service);
+
+  // $profileDir/gmp/$platform/
+  nsCOMPtr<nsIFile> path;
+  nsresult rv = service->GetStorageDir(getter_AddRefs(path));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+
+  // $profileDir/gmp/$platform/gmp-fake/
+  rv = path->Append(NS_LITERAL_STRING("gmp-fake"));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  // $profileDir/gmp/$platform/gmp-fake/$aDir/
+  rv = path->AppendNative(aDir);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  return EnumerateDir(path, aDirIter);
+}
+
+class GMPShutdownObserver : public nsIRunnable
+                          , public nsIObserver {
+public:
+  GMPShutdownObserver(already_AddRefed<nsIRunnable> aShutdownTask,
+                      already_AddRefed<nsIRunnable> Continuation,
+                      const nsACString& aNodeId)
+    : mShutdownTask(aShutdownTask)
+    , mContinuation(Continuation)
+    , mNodeId(NS_ConvertUTF8toUTF16(aNodeId))
+  {}
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(NS_IsMainThread());
+    nsCOMPtr<nsIObserverService> observerService =
+        mozilla::services::GetObserverService();
+    EXPECT_TRUE(observerService);
+    observerService->AddObserver(this, "gmp-shutdown", false);
+
+    nsCOMPtr<nsIThread> thread(GetGMPThread());
+    thread->Dispatch(mShutdownTask, NS_DISPATCH_NORMAL);
+    return NS_OK;
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject,
+                     const char* aTopic,
+                     const char16_t* aSomeData) override
+  {
+    if (!strcmp(aTopic, "gmp-shutdown") &&
+        mNodeId.Equals(nsDependentString(aSomeData))) {
+      nsCOMPtr<nsIObserverService> observerService =
+          mozilla::services::GetObserverService();
+      EXPECT_TRUE(observerService);
+      observerService->RemoveObserver(this, "gmp-shutdown");
+      nsCOMPtr<nsIThread> thread(GetGMPThread());
+      thread->Dispatch(mContinuation, NS_DISPATCH_NORMAL);
+    }
+    return NS_OK;
+  }
+
+private:
+  virtual ~GMPShutdownObserver() {}
+  nsCOMPtr<nsIRunnable> mShutdownTask;
+  nsCOMPtr<nsIRunnable> mContinuation;
+  const nsString mNodeId;
+};
+
+NS_IMPL_ISUPPORTS(GMPShutdownObserver, nsIRunnable, nsIObserver)
+
+class NotifyObserversTask : public Runnable {
+public:
+  explicit NotifyObserversTask(const char* aTopic)
+    : mTopic(aTopic)
+  {}
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(NS_IsMainThread());
+    nsCOMPtr<nsIObserverService> observerService =
+        mozilla::services::GetObserverService();
+    if (observerService) {
+      observerService->NotifyObservers(nullptr, mTopic, nullptr);
+    }
+    return NS_OK;
+  }
+  const char* mTopic;
+};
+
+class ClearGMPStorageTask : public nsIRunnable
+                          , public nsIObserver {
+public:
+  ClearGMPStorageTask(already_AddRefed<nsIRunnable> Continuation,
+                      nsIThread* aTarget, PRTime aSince)
+    : mContinuation(Continuation)
+    , mTarget(aTarget)
+    , mSince(aSince)
+  {}
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(NS_IsMainThread());
+    nsCOMPtr<nsIObserverService> observerService =
+        mozilla::services::GetObserverService();
+    EXPECT_TRUE(observerService);
+    observerService->AddObserver(this, "gmp-clear-storage-complete", false);
+    if (observerService) {
+      nsAutoString str;
+      if (mSince >= 0) {
+        str.AppendInt(static_cast<int64_t>(mSince));
+      }
+      observerService->NotifyObservers(
+          nullptr, "browser:purge-session-history", str.Data());
+    }
+    return NS_OK;
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject,
+                     const char* aTopic,
+                     const char16_t* aSomeData) override
+  {
+    if (!strcmp(aTopic, "gmp-clear-storage-complete")) {
+      nsCOMPtr<nsIObserverService> observerService =
+          mozilla::services::GetObserverService();
+      EXPECT_TRUE(observerService);
+      observerService->RemoveObserver(this, "gmp-clear-storage-complete");
+      mTarget->Dispatch(mContinuation, NS_DISPATCH_NORMAL);
+    }
+    return NS_OK;
+  }
+
+private:
+  virtual ~ClearGMPStorageTask() {}
+  nsCOMPtr<nsIRunnable> mContinuation;
+  nsCOMPtr<nsIThread> mTarget;
+  const PRTime mSince;
+};
+
+NS_IMPL_ISUPPORTS(ClearGMPStorageTask, nsIRunnable, nsIObserver)
+
+static void
+ClearGMPStorage(already_AddRefed<nsIRunnable> aContinuation,
+                nsIThread* aTarget, PRTime aSince = -1)
+{
+  RefPtr<ClearGMPStorageTask> task(
+    new ClearGMPStorageTask(Move(aContinuation), aTarget, aSince));
+  NS_DispatchToMainThread(task, NS_DISPATCH_NORMAL);
+}
+
+static void
+SimulatePBModeExit()
+{
+  NS_DispatchToMainThread(new NotifyObserversTask("last-pb-context-exited"), NS_DISPATCH_SYNC);
+}
+
+class TestGetNodeIdCallback : public GetNodeIdCallback
+{
+public:
+  TestGetNodeIdCallback(nsCString& aNodeId, nsresult& aResult)
+    : mNodeId(aNodeId),
+      mResult(aResult)
+  {
+  }
+
+  void Done(nsresult aResult, const nsACString& aNodeId)
+  {
+    mResult = aResult;
+    mNodeId = aNodeId;
+  }
+
+private:
+  nsCString& mNodeId;
+  nsresult& mResult;
+};
+
+static nsCString
+GetNodeId(const nsAString& aOrigin,
+          const nsAString& aTopLevelOrigin,
+          bool aInPBMode)
+{
+  RefPtr<GeckoMediaPluginServiceParent> service =
+    GeckoMediaPluginServiceParent::GetSingleton();
+  EXPECT_TRUE(service);
+  nsCString nodeId;
+  nsresult result;
+  UniquePtr<GetNodeIdCallback> callback(new TestGetNodeIdCallback(nodeId,
+                                                                  result));
+  // We rely on the fact that the GetNodeId implementation for
+  // GeckoMediaPluginServiceParent is synchronous.
+  nsresult rv = service->GetNodeId(aOrigin,
+                                   aTopLevelOrigin,
+                                   NS_LITERAL_STRING("gmp-fake"),
+                                   aInPBMode,
+                                   Move(callback));
+  EXPECT_TRUE(NS_SUCCEEDED(rv) && NS_SUCCEEDED(result));
+  return nodeId;
+}
+
+static bool
+IsGMPStorageIsEmpty()
+{
+  RefPtr<GeckoMediaPluginServiceParent> service =
+    GeckoMediaPluginServiceParent::GetSingleton();
+  MOZ_ASSERT(service);
+  nsCOMPtr<nsIFile> storage;
+  nsresult rv = service->GetStorageDir(getter_AddRefs(storage));
+  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  bool exists = false;
+  if (storage) {
+    storage->Exists(&exists);
+  }
+  return !exists;
+}
+
+static void
+AssertIsOnGMPThread()
+{
+  RefPtr<GeckoMediaPluginService> service =
+    GeckoMediaPluginService::GetGeckoMediaPluginService();
+  MOZ_ASSERT(service);
+  nsCOMPtr<nsIThread> thread;
+  service->GetThread(getter_AddRefs(thread));
+  MOZ_ASSERT(thread);
+  nsCOMPtr<nsIThread> currentThread;
+  DebugOnly<nsresult> rv = NS_GetCurrentThread(getter_AddRefs(currentThread));
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+  MOZ_ASSERT(currentThread == thread);
+}
+
+class GMPStorageTest : public GMPDecryptorProxyCallback
+{
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GMPStorageTest)
+
+  void DoTest(void (GMPStorageTest::*aTestMethod)()) {
+    EnsureNSSInitializedChromeOrContent();
+    nsCOMPtr<nsIThread> thread(GetGMPThread());
+    ClearGMPStorage(NewRunnableMethod(this, aTestMethod), thread);
+    AwaitFinished();
+  }
+
+  GMPStorageTest()
+    : mDecryptor(nullptr)
+    , mMonitor("GMPStorageTest")
+    , mFinished(false)
+  {
+  }
+
+  void
+  Update(const nsCString& aMessage)
+  {
+    nsTArray<uint8_t> msg;
+    msg.AppendElements(aMessage.get(), aMessage.Length());
+    mDecryptor->UpdateSession(1, NS_LITERAL_CSTRING("fake-session-id"), msg);
+  }
+
+  void TestGetNodeId()
+  {
+    AssertIsOnGMPThread();
+
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    const nsString origin1 = NS_LITERAL_STRING("http://example1.com");
+    const nsString origin2 = NS_LITERAL_STRING("http://example2.org");
+
+    nsCString PBnodeId1 = GetNodeId(origin1, origin2, true);
+    nsCString PBnodeId2 = GetNodeId(origin1, origin2, true);
+
+    // Node ids for the same origins should be the same in PB mode.
+    EXPECT_TRUE(PBnodeId1.Equals(PBnodeId2));
+
+    nsCString PBnodeId3 = GetNodeId(origin2, origin1, true);
+
+    // Node ids with origin and top level origin swapped should be different.
+    EXPECT_TRUE(!PBnodeId3.Equals(PBnodeId1));
+
+    // Getting node ids in PB mode should not result in the node id being stored.
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    nsCString nodeId1 = GetNodeId(origin1, origin2, false);
+    nsCString nodeId2 = GetNodeId(origin1, origin2, false);
+
+    // NodeIds for the same origin pair in non-pb mode should be the same.
+    EXPECT_TRUE(nodeId1.Equals(nodeId2));
+
+    // Node ids for a given origin pair should be different for the PB origins should be the same in PB mode.
+    EXPECT_TRUE(!PBnodeId1.Equals(nodeId1));
+    EXPECT_TRUE(!PBnodeId2.Equals(nodeId2));
+
+    nsCOMPtr<nsIThread> thread(GetGMPThread());
+    ClearGMPStorage(NewRunnableMethod<nsCString>(
+      this, &GMPStorageTest::TestGetNodeId_Continuation, nodeId1), thread);
+  }
+
+  void TestGetNodeId_Continuation(nsCString aNodeId1) {
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    // Once we clear storage, the node ids generated for the same origin-pair
+    // should be different.
+    const nsString origin1 = NS_LITERAL_STRING("http://example1.com");
+    const nsString origin2 = NS_LITERAL_STRING("http://example2.org");
+    nsCString nodeId3 = GetNodeId(origin1, origin2, false);
+    EXPECT_TRUE(!aNodeId1.Equals(nodeId3));
+
+    SetFinished();
+  }
+
+  class CreateDecryptorDone : public GetGMPDecryptorCallback
+  {
+  public:
+    explicit CreateDecryptorDone(GMPStorageTest* aRunner)
+      : mRunner(aRunner)
+    {
+    }
+
+    void Done(GMPDecryptorProxy* aDecryptor) override
+    {
+      mRunner->mDecryptor = aDecryptor;
+      EXPECT_TRUE(!!mRunner->mDecryptor);
+
+      if (mRunner->mDecryptor) {
+        mRunner->mDecryptor->Init(mRunner, false, true);
+      }
+    }
+
+  private:
+    RefPtr<GMPStorageTest> mRunner;
+  };
+
+  void CreateDecryptor(const nsCString& aNodeId,
+                       const nsCString& aUpdate)
+  {
+    nsTArray<nsCString> updates;
+    updates.AppendElement(aUpdate);
+    nsCOMPtr<nsIRunnable> continuation(new Updates(this, Move(updates)));
+    CreateDecryptor(aNodeId, continuation);
+  }
+
+  void CreateDecryptor(const nsAString& aOrigin,
+                       const nsAString& aTopLevelOrigin,
+                       bool aInPBMode,
+                       const nsCString& aUpdate)
+  {
+    nsTArray<nsCString> updates;
+    updates.AppendElement(aUpdate);
+    CreateDecryptor(aOrigin, aTopLevelOrigin, aInPBMode, Move(updates));
+  }
+  class Updates : public Runnable
+  {
+  public:
+    Updates(GMPStorageTest* aRunner, nsTArray<nsCString>&& aUpdates)
+      : mRunner(aRunner),
+        mUpdates(Move(aUpdates))
+    {
+    }
+
+    NS_IMETHOD Run() override
+    {
+      for (auto& update : mUpdates) {
+        mRunner->Update(update);
+      }
+      return NS_OK;
+    }
+
+  private:
+    RefPtr<GMPStorageTest> mRunner;
+    nsTArray<nsCString> mUpdates;
+  };
+  void CreateDecryptor(const nsAString& aOrigin,
+                       const nsAString& aTopLevelOrigin,
+                       bool aInPBMode,
+                       nsTArray<nsCString>&& aUpdates) {
+    nsCOMPtr<nsIRunnable> updates(new Updates(this, Move(aUpdates)));
+    CreateDecryptor(GetNodeId(aOrigin, aTopLevelOrigin, aInPBMode), updates);
+  }
+
+  void CreateDecryptor(const nsCString& aNodeId,
+                       nsIRunnable* aContinuation) {
+    RefPtr<GeckoMediaPluginService> service =
+      GeckoMediaPluginService::GetGeckoMediaPluginService();
+    EXPECT_TRUE(service);
+
+    mNodeId = aNodeId;
+    EXPECT_TRUE(!mNodeId.IsEmpty());
+
+    nsTArray<nsCString> tags;
+    tags.AppendElement(NS_LITERAL_CSTRING("fake"));
+
+    UniquePtr<GetGMPDecryptorCallback> callback(
+      new CreateDecryptorDone(this));
+
+    // Continue after the OnSetDecryptorId message, so that we don't
+    // get warnings in the async shutdown tests due to receiving the
+    // SetDecryptorId message after we've started shutdown.
+    mSetDecryptorIdContinuation = aContinuation;
+
+    nsresult rv =
+      service->GetGMPDecryptor(nullptr, &tags, mNodeId, Move(callback));
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+  }
+
+  void TestBasicStorage() {
+    AssertIsOnGMPThread();
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    RefPtr<GeckoMediaPluginService> service =
+      GeckoMediaPluginService::GetGeckoMediaPluginService();
+
+    // Send a message to the fake GMP for it to run its own tests internally.
+    // It sends us a "test-storage complete" message when its passed, or
+    // some other message if its tests fail.
+    Expect(NS_LITERAL_CSTRING("test-storage complete"),
+           NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example1.com"),
+                    NS_LITERAL_STRING("http://example2.com"),
+                    false,
+                    NS_LITERAL_CSTRING("test-storage"));
+  }
+
+  /**
+   * 1. Generate storage data for some sites.
+   * 2. Forget about one of the sites.
+   * 3. Check if the storage data for the forgotten site are erased correctly.
+   * 4. Check if the storage data for other sites remain unchanged.
+   */
+  void TestForgetThisSite() {
+    AssertIsOnGMPThread();
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    // Generate storage data for some site.
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestForgetThisSite_AnotherSite);
+    Expect(NS_LITERAL_CSTRING("test-storage complete"), r.forget());
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example1.com"),
+                    NS_LITERAL_STRING("http://example2.com"),
+                    false,
+                    NS_LITERAL_CSTRING("test-storage"));
+  }
+
+  void TestForgetThisSite_AnotherSite() {
+    Shutdown();
+
+    // Generate storage data for another site.
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestForgetThisSite_CollectSiteInfo);
+    Expect(NS_LITERAL_CSTRING("test-storage complete"), r.forget());
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example3.com"),
+                    NS_LITERAL_STRING("http://example4.com"),
+                    false,
+                    NS_LITERAL_CSTRING("test-storage"));
+  }
+
+  struct NodeInfo {
+    explicit NodeInfo(const nsACString& aSite,
+                      const mozilla::OriginAttributesPattern& aPattern)
+      : siteToForget(aSite)
+      , mPattern(aPattern)
+    { }
+    nsCString siteToForget;
+    mozilla::OriginAttributesPattern mPattern;
+    nsTArray<nsCString> expectedRemainingNodeIds;
+  };
+
+  class NodeIdCollector {
+  public:
+    explicit NodeIdCollector(NodeInfo* aInfo) : mNodeInfo(aInfo) {}
+    void operator()(nsIFile* aFile) {
+      nsCString salt;
+      nsresult rv = ReadSalt(aFile, salt);
+      ASSERT_TRUE(NS_SUCCEEDED(rv));
+      if (!MatchOrigin(aFile, mNodeInfo->siteToForget, mNodeInfo->mPattern)) {
+        mNodeInfo->expectedRemainingNodeIds.AppendElement(salt);
+      }
+    }
+  private:
+    NodeInfo* mNodeInfo;
+  };
+
+  void TestForgetThisSite_CollectSiteInfo() {
+    mozilla::OriginAttributesPattern pattern;
+
+    nsAutoPtr<NodeInfo> siteInfo(
+        new NodeInfo(NS_LITERAL_CSTRING("http://example1.com"),
+                     pattern));
+    // Collect nodeIds that are expected to remain for later comparison.
+    EnumerateGMPStorageDir(NS_LITERAL_CSTRING("id"), NodeIdCollector(siteInfo));
+    // Invoke "Forget this site" on the main thread.
+    NS_DispatchToMainThread(NewRunnableMethod<nsAutoPtr<NodeInfo>>(
+        this, &GMPStorageTest::TestForgetThisSite_Forget, siteInfo));
+  }
+
+  void TestForgetThisSite_Forget(nsAutoPtr<NodeInfo> aSiteInfo) {
+    RefPtr<GeckoMediaPluginServiceParent> service =
+        GeckoMediaPluginServiceParent::GetSingleton();
+    service->ForgetThisSiteNative(NS_ConvertUTF8toUTF16(aSiteInfo->siteToForget),
+                                  aSiteInfo->mPattern);
+
+    nsCOMPtr<nsIThread> thread;
+    service->GetThread(getter_AddRefs(thread));
+
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod<nsAutoPtr<NodeInfo>>(
+        this, &GMPStorageTest::TestForgetThisSite_Verify, aSiteInfo);
+    thread->Dispatch(r, NS_DISPATCH_NORMAL);
+
+    nsCOMPtr<nsIRunnable> f = NewRunnableMethod(
+        this, &GMPStorageTest::SetFinished);
+    thread->Dispatch(f, NS_DISPATCH_NORMAL);
+  }
+
+  class NodeIdVerifier {
+  public:
+    explicit NodeIdVerifier(const NodeInfo* aInfo)
+      : mNodeInfo(aInfo)
+      , mExpectedRemainingNodeIds(aInfo->expectedRemainingNodeIds) {}
+    void operator()(nsIFile* aFile) {
+      nsCString salt;
+      nsresult rv = ReadSalt(aFile, salt);
+      ASSERT_TRUE(NS_SUCCEEDED(rv));
+      // Shouldn't match the origin if we clear correctly.
+      EXPECT_FALSE(MatchOrigin(aFile, mNodeInfo->siteToForget, mNodeInfo->mPattern));
+      // Check if remaining nodeIDs are as expected.
+      EXPECT_TRUE(mExpectedRemainingNodeIds.RemoveElement(salt));
+    }
+    ~NodeIdVerifier() {
+      EXPECT_TRUE(mExpectedRemainingNodeIds.IsEmpty());
+    }
+  private:
+    const NodeInfo* mNodeInfo;
+    nsTArray<nsCString> mExpectedRemainingNodeIds;
+  };
+
+  class StorageVerifier {
+  public:
+    explicit StorageVerifier(const NodeInfo* aInfo)
+      : mExpectedRemainingNodeIds(aInfo->expectedRemainingNodeIds) {}
+    void operator()(nsIFile* aFile) {
+      nsCString salt;
+      nsresult rv = aFile->GetNativeLeafName(salt);
+      ASSERT_TRUE(NS_SUCCEEDED(rv));
+      EXPECT_TRUE(mExpectedRemainingNodeIds.RemoveElement(salt));
+    }
+    ~StorageVerifier() {
+      EXPECT_TRUE(mExpectedRemainingNodeIds.IsEmpty());
+    }
+  private:
+    nsTArray<nsCString> mExpectedRemainingNodeIds;
+  };
+
+  void TestForgetThisSite_Verify(nsAutoPtr<NodeInfo> aSiteInfo) {
+    nsresult rv = EnumerateGMPStorageDir(
+        NS_LITERAL_CSTRING("id"), NodeIdVerifier(aSiteInfo));
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+
+    rv = EnumerateGMPStorageDir(
+        NS_LITERAL_CSTRING("storage"), StorageVerifier(aSiteInfo));
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+  }
+
+  /**
+   * 1. Generate some storage data.
+   * 2. Find the max mtime |t| in $profileDir/gmp/$platform/gmp-fake/id/.
+   * 3. Pass |t| to clear recent history.
+   * 4. Check if all directories in $profileDir/gmp/$platform/gmp-fake/id/ and
+   *    $profileDir/gmp/$platform/gmp-fake/storage are removed.
+   */
+  void TestClearRecentHistory1() {
+    AssertIsOnGMPThread();
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    // Generate storage data for some site.
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestClearRecentHistory1_Clear);
+    Expect(NS_LITERAL_CSTRING("test-storage complete"), r.forget());
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example1.com"),
+                    NS_LITERAL_STRING("http://example2.com"),
+                    false,
+                    NS_LITERAL_CSTRING("test-storage"));
+}
+
+  /**
+   * 1. Generate some storage data.
+   * 2. Find the max mtime |t| in $profileDir/gmp/$platform/gmp-fake/storage/.
+   * 3. Pass |t| to clear recent history.
+   * 4. Check if all directories in $profileDir/gmp/$platform/gmp-fake/id/ and
+   *    $profileDir/gmp/$platform/gmp-fake/storage are removed.
+   */
+  void TestClearRecentHistory2() {
+    AssertIsOnGMPThread();
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    // Generate storage data for some site.
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestClearRecentHistory2_Clear);
+    Expect(NS_LITERAL_CSTRING("test-storage complete"), r.forget());
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example1.com"),
+                    NS_LITERAL_STRING("http://example2.com"),
+                    false,
+                    NS_LITERAL_CSTRING("test-storage"));
+  }
+
+  /**
+   * 1. Generate some storage data.
+   * 2. Find the max mtime |t| in $profileDir/gmp/$platform/gmp-fake/storage/.
+   * 3. Pass |t+1| to clear recent history.
+   * 4. Check if all directories in $profileDir/gmp/$platform/gmp-fake/id/ and
+   *    $profileDir/gmp/$platform/gmp-fake/storage remain unchanged.
+   */
+  void TestClearRecentHistory3() {
+    AssertIsOnGMPThread();
+    EXPECT_TRUE(IsGMPStorageIsEmpty());
+
+    // Generate storage data for some site.
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestClearRecentHistory3_Clear);
+    Expect(NS_LITERAL_CSTRING("test-storage complete"), r.forget());
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example1.com"),
+                    NS_LITERAL_STRING("http://example2.com"),
+                    false,
+                    NS_LITERAL_CSTRING("test-storage"));
+  }
+
+  class MaxMTimeFinder {
+  public:
+    MaxMTimeFinder() : mMaxTime(0) {}
+    void operator()(nsIFile* aFile) {
+      PRTime lastModified;
+      nsresult rv = aFile->GetLastModifiedTime(&lastModified);
+      if (NS_SUCCEEDED(rv) && lastModified > mMaxTime) {
+        mMaxTime = lastModified;
+      }
+      EnumerateDir(aFile, *this);
+    }
+    PRTime GetResult() const { return mMaxTime; }
+  private:
+    PRTime mMaxTime;
+  };
+
+  void TestClearRecentHistory1_Clear() {
+    MaxMTimeFinder f;
+    nsresult rv = EnumerateGMPStorageDir(NS_LITERAL_CSTRING("id"), f);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestClearRecentHistory_CheckEmpty);
+    nsCOMPtr<nsIThread> t(GetGMPThread());
+    ClearGMPStorage(r.forget(), t, f.GetResult());
+  }
+
+  void TestClearRecentHistory2_Clear() {
+    MaxMTimeFinder f;
+    nsresult rv = EnumerateGMPStorageDir(NS_LITERAL_CSTRING("storage"), f);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestClearRecentHistory_CheckEmpty);
+    nsCOMPtr<nsIThread> t(GetGMPThread());
+    ClearGMPStorage(r.forget(), t, f.GetResult());
+  }
+
+  void TestClearRecentHistory3_Clear() {
+    MaxMTimeFinder f;
+    nsresult rv = EnumerateGMPStorageDir(NS_LITERAL_CSTRING("storage"), f);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
+        this, &GMPStorageTest::TestClearRecentHistory_CheckNonEmpty);
+    nsCOMPtr<nsIThread> t(GetGMPThread());
+    ClearGMPStorage(r.forget(), t, f.GetResult() + 1);
+  }
+
+  class FileCounter {
+  public:
+    FileCounter() : mCount(0) {}
+    void operator()(nsIFile* aFile) {
+      ++mCount;
+    }
+    int GetCount() const { return mCount; }
+  private:
+    int mCount;
+  };
+
+  void TestClearRecentHistory_CheckEmpty() {
+    FileCounter c1;
+    nsresult rv = EnumerateGMPStorageDir(NS_LITERAL_CSTRING("id"), c1);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    // There should be no files under $profileDir/gmp/$platform/gmp-fake/id/
+    EXPECT_EQ(c1.GetCount(), 0);
+
+    FileCounter c2;
+    rv = EnumerateGMPStorageDir(NS_LITERAL_CSTRING("storage"), c2);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    // There should be no files under $profileDir/gmp/$platform/gmp-fake/storage/
+    EXPECT_EQ(c2.GetCount(), 0);
+
+    SetFinished();
+  }
+
+  void TestClearRecentHistory_CheckNonEmpty() {
+    FileCounter c1;
+    nsresult rv = EnumerateGMPStorageDir(NS_LITERAL_CSTRING("id"), c1);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    // There should be one directory under $profileDir/gmp/$platform/gmp-fake/id/
+    EXPECT_EQ(c1.GetCount(), 1);
+
+    FileCounter c2;
+    rv = EnumerateGMPStorageDir(NS_LITERAL_CSTRING("storage"), c2);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    // There should be one directory under $profileDir/gmp/$platform/gmp-fake/storage/
+    EXPECT_EQ(c2.GetCount(), 1);
+
+    SetFinished();
+  }
+
+  void TestCrossOriginStorage() {
+    EXPECT_TRUE(!mDecryptor);
+
+    // Send the decryptor the message "store recordid $time"
+    // Wait for the decrytor to send us "stored recordid $time"
+    auto t = time(0);
+    nsCString response("stored crossOriginTestRecordId ");
+    response.AppendInt((int64_t)t);
+    Expect(response, NewRunnableMethod(this,
+      &GMPStorageTest::TestCrossOriginStorage_RecordStoredContinuation));
+
+    nsCString update("store crossOriginTestRecordId ");
+    update.AppendInt((int64_t)t);
+
+    // Open decryptor on one, origin, write a record, and test that that
+    // record can't be read on another origin.
+    CreateDecryptor(NS_LITERAL_STRING("http://example3.com"),
+                    NS_LITERAL_STRING("http://example4.com"),
+                    false,
+                    update);
+  }
+
+  void TestCrossOriginStorage_RecordStoredContinuation() {
+    // Close the old decryptor, and create a new one on a different origin,
+    // and try to read the record.
+    Shutdown();
+
+    Expect(NS_LITERAL_CSTRING("retrieve crossOriginTestRecordId succeeded (length 0 bytes)"),
+           NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example5.com"),
+                    NS_LITERAL_STRING("http://example6.com"),
+                    false,
+                    NS_LITERAL_CSTRING("retrieve crossOriginTestRecordId"));
+  }
+
+  void TestPBStorage() {
+    // Send the decryptor the message "store recordid $time"
+    // Wait for the decrytor to send us "stored recordid $time"
+    nsCString response("stored pbdata test-pb-data");
+    Expect(response, NewRunnableMethod(this,
+      &GMPStorageTest::TestPBStorage_RecordStoredContinuation));
+
+    // Open decryptor on one, origin, write a record, close decryptor,
+    // open another, and test that record can be read, close decryptor,
+    // then send pb-last-context-closed notification, then open decryptor
+    // and check that it can't read that data; it should have been purged.
+    CreateDecryptor(NS_LITERAL_STRING("http://pb1.com"),
+                    NS_LITERAL_STRING("http://pb2.com"),
+                    true,
+                    NS_LITERAL_CSTRING("store pbdata test-pb-data"));
+  }
+
+  void TestPBStorage_RecordStoredContinuation() {
+    Shutdown();
+
+    Expect(NS_LITERAL_CSTRING("retrieve pbdata succeeded (length 12 bytes)"),
+           NewRunnableMethod(this,
+              &GMPStorageTest::TestPBStorage_RecordRetrievedContinuation));
+
+    CreateDecryptor(NS_LITERAL_STRING("http://pb1.com"),
+                    NS_LITERAL_STRING("http://pb2.com"),
+                    true,
+                    NS_LITERAL_CSTRING("retrieve pbdata"));
+  }
+
+  void TestPBStorage_RecordRetrievedContinuation() {
+    Shutdown();
+    SimulatePBModeExit();
+
+    Expect(NS_LITERAL_CSTRING("retrieve pbdata succeeded (length 0 bytes)"),
+           NewRunnableMethod(this,
+              &GMPStorageTest::SetFinished));
+
+    CreateDecryptor(NS_LITERAL_STRING("http://pb1.com"),
+                    NS_LITERAL_STRING("http://pb2.com"),
+                    true,
+                    NS_LITERAL_CSTRING("retrieve pbdata"));
+  }
+
+  void NextAsyncShutdownTimeoutTest(nsIRunnable* aContinuation)
+  {
+    if (mDecryptor) {
+      Update(NS_LITERAL_CSTRING("shutdown-mode timeout"));
+      Shutdown();
+    }
+    nsCOMPtr<nsIThread> thread(GetGMPThread());
+    thread->Dispatch(aContinuation, NS_DISPATCH_NORMAL);
+  }
+
+  void CreateAsyncShutdownTimeoutGMP(const nsAString& aOrigin1,
+                                     const nsAString& aOrigin2,
+                                     void (GMPStorageTest::*aCallback)()) {
+    nsCOMPtr<nsIRunnable> continuation(
+      NewRunnableMethod<nsCOMPtr<nsIRunnable>>(
+        this,
+        &GMPStorageTest::NextAsyncShutdownTimeoutTest,
+        NewRunnableMethod(this, aCallback)));
+
+    CreateDecryptor(GetNodeId(aOrigin1, aOrigin2, false), continuation);
+  }
+
+  void TestAsyncShutdownTimeout() {
+    // Create decryptors that timeout in their async shutdown.
+    // If the gtest hangs on shutdown, test fails!
+    CreateAsyncShutdownTimeoutGMP(NS_LITERAL_STRING("http://example7.com"),
+                                  NS_LITERAL_STRING("http://example8.com"),
+                                  &GMPStorageTest::TestAsyncShutdownTimeout2);
+  };
+
+  void TestAsyncShutdownTimeout2() {
+    CreateAsyncShutdownTimeoutGMP(NS_LITERAL_STRING("http://example9.com"),
+                                  NS_LITERAL_STRING("http://example10.com"),
+                                  &GMPStorageTest::TestAsyncShutdownTimeout3);
+  };
+
+  void TestAsyncShutdownTimeout3() {
+    CreateAsyncShutdownTimeoutGMP(NS_LITERAL_STRING("http://example11.com"),
+                                  NS_LITERAL_STRING("http://example12.com"),
+                                  &GMPStorageTest::SetFinished);
+  };
+
+  void TestAsyncShutdownStorage() {
+    // Instruct the GMP to write a token (the current timestamp, so it's
+    // unique) during async shutdown, then shutdown the plugin, re-create
+    // it, and check that the token was successfully stored.
+    auto t = time(0);
+    nsCString update("shutdown-mode token ");
+    nsCString token;
+    token.AppendInt((int64_t)t);
+    update.Append(token);
+
+    // Wait for a response from the GMP, so we know it's had time to receive
+    // the token.
+    nsCString response("shutdown-token received ");
+    response.Append(token);
+    Expect(response, NewRunnableMethod<nsCString>(this,
+      &GMPStorageTest::TestAsyncShutdownStorage_ReceivedShutdownToken, token));
+
+    // Test that a GMP can write to storage during shutdown, and retrieve
+    // that written data in a subsequent session.
+    CreateDecryptor(NS_LITERAL_STRING("http://example13.com"),
+                    NS_LITERAL_STRING("http://example14.com"),
+                    false,
+                    update);
+  }
+
+  void TestAsyncShutdownStorage_ReceivedShutdownToken(const nsCString& aToken) {
+    ShutdownThen(NewRunnableMethod<nsCString>(this,
+      &GMPStorageTest::TestAsyncShutdownStorage_AsyncShutdownComplete, aToken));
+  }
+
+  void TestAsyncShutdownStorage_AsyncShutdownComplete(const nsCString& aToken) {
+    // Create a new instance of the plugin, retrieve the token written
+    // during shutdown and verify it is correct.
+    nsCString response("retrieved shutdown-token ");
+    response.Append(aToken);
+    Expect(response,
+           NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example13.com"),
+                    NS_LITERAL_STRING("http://example14.com"),
+                    false,
+                    NS_LITERAL_CSTRING("retrieve-shutdown-token"));
+  }
+
+#if defined(XP_WIN)
+  void TestOutputProtection() {
+    Shutdown();
+
+    Expect(NS_LITERAL_CSTRING("OP tests completed"),
+           NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example15.com"),
+                    NS_LITERAL_STRING("http://example16.com"),
+                    false,
+                    NS_LITERAL_CSTRING("test-op-apis"));
+  }
+#endif
+
+  void TestPluginVoucher() {
+    Expect(NS_LITERAL_CSTRING("retrieved plugin-voucher: gmp-fake placeholder voucher"),
+           NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+
+    CreateDecryptor(NS_LITERAL_STRING("http://example17.com"),
+                    NS_LITERAL_STRING("http://example18.com"),
+                    false,
+                    NS_LITERAL_CSTRING("retrieve-plugin-voucher"));
+  }
+
+  void TestGetRecordNamesInMemoryStorage() {
+    TestGetRecordNames(true);
+  }
+
+  nsCString mRecordNames;
+
+  void AppendIntPadded(nsACString& aString, uint32_t aInt) {
+    if (aInt > 0 && aInt < 10) {
+      aString.AppendLiteral("0");
+    }
+    aString.AppendInt(aInt);
+  }
+
+  void TestGetRecordNames(bool aPrivateBrowsing) {
+    // Create a number of records of different names.
+    const uint32_t num = 100;
+    nsTArray<nsCString> updates(num);
+    for (uint32_t i = 0; i < num; i++) {
+      nsAutoCString response;
+      response.AppendLiteral("stored data");
+      AppendIntPadded(response, i);
+      response.AppendLiteral(" test-data");
+      AppendIntPadded(response, i);
+
+      if (i != 0) {
+        mRecordNames.AppendLiteral(",");
+      }
+      mRecordNames.AppendLiteral("data");
+      AppendIntPadded(mRecordNames, i);
+
+      nsCString& update = *updates.AppendElement();
+      update.AppendLiteral("store data");
+      AppendIntPadded(update, i);
+      update.AppendLiteral(" test-data");
+      AppendIntPadded(update, i);
+
+      nsCOMPtr<nsIRunnable> continuation;
+      if (i + 1 == num) {
+        continuation =
+          NewRunnableMethod(this, &GMPStorageTest::TestGetRecordNames_QueryNames);
+      }
+      Expect(response, continuation.forget());
+    }
+
+    CreateDecryptor(NS_LITERAL_STRING("http://foo.com"),
+                    NS_LITERAL_STRING("http://bar.com"),
+                    aPrivateBrowsing,
+                    Move(updates));
+  }
+
+  void TestGetRecordNames_QueryNames() {
+    nsCString response("record-names ");
+    response.Append(mRecordNames);
+    Expect(response,
+           NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+    Update(NS_LITERAL_CSTRING("retrieve-record-names"));
+  }
+
+  void GetRecordNamesPersistentStorage() {
+    TestGetRecordNames(false);
+  }
+
+  void TestLongRecordNames() {
+    NS_NAMED_LITERAL_CSTRING(longRecordName,
+      "A_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
+      "long_record_name");
+
+    NS_NAMED_LITERAL_CSTRING(data, "Just_some_arbitrary_data.");
+
+    MOZ_ASSERT(longRecordName.Length() < GMP_MAX_RECORD_NAME_SIZE);
+    MOZ_ASSERT(longRecordName.Length() > 260); // Windows MAX_PATH
+
+    nsCString response("stored ");
+    response.Append(longRecordName);
+    response.AppendLiteral(" ");
+    response.Append(data);
+    Expect(response, NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+
+    nsCString update("store ");
+    update.Append(longRecordName);
+    update.AppendLiteral(" ");
+    update.Append(data);
+    CreateDecryptor(NS_LITERAL_STRING("http://fuz.com"),
+                    NS_LITERAL_STRING("http://baz.com"),
+                    false,
+                    update);
+  }
+
+  void TestNodeId() {
+    // Calculate the nodeId, and the device bound nodeId. Start a GMP, and
+    // have it return the device bound nodeId that it's been passed. Assert
+    // they have the same value.
+    const nsString origin = NS_LITERAL_STRING("http://example-fuz-baz.com");
+    nsCString originSalt1 = GetNodeId(origin, origin, false);
+
+    nsCString salt = originSalt1;
+    std::string nodeId;
+    EXPECT_TRUE(CalculateGMPDeviceId(salt.BeginWriting(), salt.Length(), nodeId));
+
+    std::string expected = "node-id " + nodeId;
+    Expect(nsDependentCString(expected.c_str()), NewRunnableMethod(this, &GMPStorageTest::SetFinished));
+
+    CreateDecryptor(originSalt1,
+                    NS_LITERAL_CSTRING("retrieve-node-id"));
+  }
+
+  void Expect(const nsCString& aMessage, already_AddRefed<nsIRunnable> aContinuation) {
+    mExpected.AppendElement(ExpectedMessage(aMessage, Move(aContinuation)));
+  }
+
+  void AwaitFinished() {
+    while (!mFinished) {
+      NS_ProcessNextEvent(nullptr, true);
+    }
+    mFinished = false;
+  }
+
+  void ShutdownThen(already_AddRefed<nsIRunnable> aContinuation) {
+    EXPECT_TRUE(!!mDecryptor);
+    if (!mDecryptor) {
+      return;
+    }
+    EXPECT_FALSE(mNodeId.IsEmpty());
+    RefPtr<GMPShutdownObserver> task(
+      new GMPShutdownObserver(NewRunnableMethod(this, &GMPStorageTest::Shutdown),
+                              Move(aContinuation), mNodeId));
+    NS_DispatchToMainThread(task, NS_DISPATCH_NORMAL);
+  }
+
+  void Shutdown() {
+    if (mDecryptor) {
+      mDecryptor->Close();
+      mDecryptor = nullptr;
+      mNodeId = EmptyCString();
+    }
+  }
+
+  void Dummy() {
+  }
+
+  void SetFinished() {
+    mFinished = true;
+    Shutdown();
+    NS_DispatchToMainThread(NewRunnableMethod(this, &GMPStorageTest::Dummy));
+  }
+
+  void SessionMessage(const nsCString& aSessionId,
+                      mozilla::dom::MediaKeyMessageType aMessageType,
+                      const nsTArray<uint8_t>& aMessage) override
+  {
+    MonitorAutoLock mon(mMonitor);
+
+    nsCString msg((const char*)aMessage.Elements(), aMessage.Length());
+    EXPECT_TRUE(mExpected.Length() > 0);
+    bool matches = mExpected[0].mMessage.Equals(msg);
+    EXPECT_STREQ(mExpected[0].mMessage.get(), msg.get());
+    if (mExpected.Length() > 0 && matches) {
+      nsCOMPtr<nsIRunnable> continuation = mExpected[0].mContinuation;
+      mExpected.RemoveElementAt(0);
+      if (continuation) {
+        NS_DispatchToCurrentThread(continuation);
+      }
+    }
+  }
+
+  void SetDecryptorId(uint32_t aId) override
+  {
+    if (!mSetDecryptorIdContinuation) {
+      return;
+    }
+    nsCOMPtr<nsIThread> thread(GetGMPThread());
+    thread->Dispatch(mSetDecryptorIdContinuation, NS_DISPATCH_NORMAL);
+    mSetDecryptorIdContinuation = nullptr;
+  }
+
+  void SetSessionId(uint32_t aCreateSessionToken,
+                    const nsCString& aSessionId) override { }
+  void ResolveLoadSessionPromise(uint32_t aPromiseId,
+                                 bool aSuccess) override {}
+  void ResolvePromise(uint32_t aPromiseId) override {}
+  void RejectPromise(uint32_t aPromiseId,
+                     nsresult aException,
+                     const nsCString& aSessionId) override { }
+  void ExpirationChange(const nsCString& aSessionId,
+                        UnixTime aExpiryTime) override {}
+  void SessionClosed(const nsCString& aSessionId) override {}
+  void SessionError(const nsCString& aSessionId,
+                    nsresult aException,
+                    uint32_t aSystemCode,
+                    const nsCString& aMessage) override {}
+  void Decrypted(uint32_t aId,
+                 mozilla::DecryptStatus aResult,
+                 const nsTArray<uint8_t>& aDecryptedData) override { }
+
+  void BatchedKeyStatusChanged(const nsCString& aSessionId,
+                               const nsTArray<CDMKeyInfo>& aKeyInfos) override { }
+
+  void Terminated() override {
+    if (mDecryptor) {
+      mDecryptor->Close();
+      mDecryptor = nullptr;
+    }
+  }
+
+private:
+  ~GMPStorageTest() { }
+
+  struct ExpectedMessage {
+    ExpectedMessage(const nsCString& aMessage, already_AddRefed<nsIRunnable> aContinuation)
+      : mMessage(aMessage)
+      , mContinuation(aContinuation)
+    {}
+    nsCString mMessage;
+    nsCOMPtr<nsIRunnable> mContinuation;
+  };
+
+  nsTArray<ExpectedMessage> mExpected;
+
+  RefPtr<nsIRunnable> mSetDecryptorIdContinuation;
+
+  GMPDecryptorProxy* mDecryptor;
+  Monitor mMonitor;
+  Atomic<bool> mFinished;
+  nsCString mNodeId;
+};
+
+void
+GMPTestRunner::DoTest(void (GMPTestRunner::*aTestMethod)(GMPTestMonitor&))
+{
+  nsCOMPtr<nsIThread> thread(GetGMPThread());
+
+  GMPTestMonitor monitor;
+  thread->Dispatch(NewRunnableMethod<GMPTestMonitor&>(this,
+                                                      aTestMethod,
+                                                      monitor),
+                   NS_DISPATCH_NORMAL);
+  monitor.AwaitFinished();
+}
+
+TEST(GeckoMediaPlugins, GMPTestCodec) {
+  RefPtr<GMPTestRunner> runner = new GMPTestRunner();
+  runner->DoTest(&GMPTestRunner::RunTestGMPTestCodec1);
+  runner->DoTest(&GMPTestRunner::RunTestGMPTestCodec2);
+  runner->DoTest(&GMPTestRunner::RunTestGMPTestCodec3);
+}
+
+TEST(GeckoMediaPlugins, GMPCrossOrigin) {
+  RefPtr<GMPTestRunner> runner = new GMPTestRunner();
+  runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin1);
+  runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin2);
+  runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin3);
+  runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin4);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageGetNodeId) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestGetNodeId);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageBasic) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestBasicStorage);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageForgetThisSite) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestForgetThisSite);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageClearRecentHistory1) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestClearRecentHistory1);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageClearRecentHistory2) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestClearRecentHistory2);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageClearRecentHistory3) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestClearRecentHistory3);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageCrossOrigin) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestCrossOriginStorage);
+}
+
+TEST(GeckoMediaPlugins, GMPStoragePrivateBrowsing) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestPBStorage);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageAsyncShutdownTimeout) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestAsyncShutdownTimeout);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageAsyncShutdownStorage) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestAsyncShutdownStorage);
+}
+
+TEST(GeckoMediaPlugins, GMPPluginVoucher) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestPluginVoucher);
+}
+
+#if defined(XP_WIN)
+TEST(GeckoMediaPlugins, GMPOutputProtection) {
+  // Output Protection is not available pre-Vista.
+  if (!IsVistaOrLater()) {
+    return;
+  }
+
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestOutputProtection);
+}
+#endif
+
+TEST(GeckoMediaPlugins, GMPStorageGetRecordNamesInMemoryStorage) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestGetRecordNamesInMemoryStorage);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageGetRecordNamesPersistentStorage) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::GetRecordNamesPersistentStorage);
+}
+
+TEST(GeckoMediaPlugins, GMPStorageLongRecordNames) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestLongRecordNames);
+}
+
+TEST(GeckoMediaPlugins, GMPNodeId) {
+  RefPtr<GMPStorageTest> runner = new GMPStorageTest();
+  runner->DoTest(&GMPStorageTest::TestNodeId);
+}
diff --git a/dom/media/gtest/TestGMPRemoveAndDelete.cpp b/dom/media/gtest/TestGMPRemoveAndDelete.cpp
new file mode 100644
index 000000000..4ac92e34e
--- /dev/null
+++ b/dom/media/gtest/TestGMPRemoveAndDelete.cpp
@@ -0,0 +1,491 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "GMPService.h"
+#include "GMPTestMonitor.h"
+#include "gmp-api/gmp-video-host.h"
+#include "gtest/gtest.h"
+#include "mozilla/Services.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIObserverService.h"
+#include "GMPVideoDecoderProxy.h"
+#include "GMPServiceParent.h"
+#include "GMPService.h"
+#include "GMPUtils.h"
+#include "mozilla/StaticPtr.h"
+#include "MediaPrefs.h"
+
+#define GMP_DIR_NAME NS_LITERAL_STRING("gmp-fakeopenh264")
+#define GMP_OLD_VERSION NS_LITERAL_STRING("1.0")
+#define GMP_NEW_VERSION NS_LITERAL_STRING("1.1")
+
+#define GMP_DELETED_TOPIC "gmp-directory-deleted"
+
+#define EXPECT_OK(X) EXPECT_TRUE(NS_SUCCEEDED(X))
+
+using namespace mozilla;
+using namespace mozilla::gmp;
+
+class GMPRemoveTest : public nsIObserver
+                    , public GMPVideoDecoderCallbackProxy
+{
+public:
+  GMPRemoveTest();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  // Called when a GMP plugin directory has been successfully deleted.
+  // |aData| will contain the directory path.
+  NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+                     const char16_t* aData) override;
+
+  // Create a new GMP plugin directory that we can trash and add it to the GMP
+  // service. Remove the original plugin directory. Original plugin directory
+  // gets re-added at destruction.
+  void Setup();
+
+  bool CreateVideoDecoder(nsCString aNodeId = EmptyCString());
+  void CloseVideoDecoder();
+
+  void DeletePluginDirectory(bool aCanDefer);
+
+  // Decode a dummy frame.
+  GMPErr Decode();
+
+  // Wait until TestMonitor has been signaled.
+  void Wait();
+
+  // Did we get a Terminated() callback from the plugin?
+  bool IsTerminated();
+
+  // From GMPVideoDecoderCallbackProxy
+  // Set mDecodeResult; unblock TestMonitor.
+  virtual void Decoded(GMPVideoi420Frame* aDecodedFrame) override;
+  virtual void Error(GMPErr aError) override;
+
+  // From GMPVideoDecoderCallbackProxy
+  // We expect this to be called when a plugin has been forcibly closed.
+  virtual void Terminated() override;
+
+  // Ignored GMPVideoDecoderCallbackProxy members
+  virtual void ReceivedDecodedReferenceFrame(const uint64_t aPictureId) override {}
+  virtual void ReceivedDecodedFrame(const uint64_t aPictureId) override {}
+  virtual void InputDataExhausted() override {}
+  virtual void DrainComplete() override {}
+  virtual void ResetComplete() override {}
+
+private:
+  virtual ~GMPRemoveTest();
+
+  void gmp_Decode();
+  void gmp_GetVideoDecoder(nsCString aNodeId,
+                           GMPVideoDecoderProxy** aOutDecoder,
+                           GMPVideoHost** aOutHost);
+  void GeneratePlugin();
+
+  GMPTestMonitor mTestMonitor;
+  nsCOMPtr<nsIThread> mGMPThread;
+
+  bool mIsTerminated;
+
+  // Path to the cloned GMP we have created.
+  nsString mTmpPath;
+  nsCOMPtr<nsIFile> mTmpDir;
+
+  // Path to the original GMP. Store so that we can re-add it after we're done
+  // testing.
+  nsString mOriginalPath;
+
+  GMPVideoDecoderProxy* mDecoder;
+  GMPVideoHost* mHost;
+  GMPErr mDecodeResult;
+};
+
+/*
+ * Simple test that the plugin is deleted when forcibly removed and deleted.
+ */
+TEST(GeckoMediaPlugins, RemoveAndDeleteForcedSimple)
+{
+  RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
+
+  test->Setup();
+  test->DeletePluginDirectory(false /* force immediate */);
+  test->Wait();
+}
+
+/*
+ * Simple test that the plugin is deleted when deferred deletion is allowed.
+ */
+TEST(GeckoMediaPlugins, RemoveAndDeleteDeferredSimple)
+{
+  RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
+
+  test->Setup();
+  test->DeletePluginDirectory(true /* can defer */);
+  test->Wait();
+}
+
+/*
+ * Test that the plugin is unavailable immediately after a forced
+ * RemoveAndDelete, and that the plugin is deleted afterwards.
+ */
+TEST(GeckoMediaPlugins, RemoveAndDeleteForcedInUse)
+{
+  RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
+
+  test->Setup();
+  EXPECT_TRUE(test->CreateVideoDecoder(NS_LITERAL_CSTRING("thisOrigin")));
+
+  // Test that we can decode a frame.
+  GMPErr err = test->Decode();
+  EXPECT_EQ(err, GMPNoErr);
+
+  test->DeletePluginDirectory(false /* force immediate */);
+  test->Wait();
+
+  // Test that the VideoDecoder is no longer available.
+  EXPECT_FALSE(test->CreateVideoDecoder(NS_LITERAL_CSTRING("thisOrigin")));
+
+  // Test that we were notified of the plugin's destruction.
+  EXPECT_TRUE(test->IsTerminated());
+}
+
+/*
+ * Test that the plugin is still usable after a deferred RemoveAndDelete, and
+ * that the plugin is deleted afterwards.
+ */
+TEST(GeckoMediaPlugins, RemoveAndDeleteDeferredInUse)
+{
+  RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
+
+  test->Setup();
+  EXPECT_TRUE(test->CreateVideoDecoder(NS_LITERAL_CSTRING("thisOrigin")));
+
+  // Make sure decoding works before we do anything.
+  GMPErr err = test->Decode();
+  EXPECT_EQ(err, GMPNoErr);
+
+  test->DeletePluginDirectory(true /* can defer */);
+
+  // Test that decoding still works.
+  err = test->Decode();
+  EXPECT_EQ(err, GMPNoErr);
+
+  // Test that this origin is still able to fetch the video decoder.
+  EXPECT_TRUE(test->CreateVideoDecoder(NS_LITERAL_CSTRING("thisOrigin")));
+
+  test->CloseVideoDecoder();
+  test->Wait();
+}
+
+static StaticRefPtr<GeckoMediaPluginService> gService;
+static StaticRefPtr<GeckoMediaPluginServiceParent> gServiceParent;
+
+static GeckoMediaPluginService*
+GetService()
+{
+  if (!gService) {
+    RefPtr<GeckoMediaPluginService> service =
+      GeckoMediaPluginService::GetGeckoMediaPluginService();
+    gService = service;
+  }
+
+  return gService.get();
+}
+
+static GeckoMediaPluginServiceParent*
+GetServiceParent()
+{
+  if (!gServiceParent) {
+    RefPtr<GeckoMediaPluginServiceParent> parent =
+      GeckoMediaPluginServiceParent::GetSingleton();
+    gServiceParent = parent;
+  }
+
+  return gServiceParent.get();
+}
+
+NS_IMPL_ISUPPORTS(GMPRemoveTest, nsIObserver)
+
+GMPRemoveTest::GMPRemoveTest()
+  : mIsTerminated(false)
+  , mDecoder(nullptr)
+  , mHost(nullptr)
+{
+}
+
+GMPRemoveTest::~GMPRemoveTest()
+{
+  bool exists;
+  EXPECT_TRUE(NS_SUCCEEDED(mTmpDir->Exists(&exists)) && !exists);
+
+  EXPECT_OK(GetServiceParent()->AddPluginDirectory(mOriginalPath));
+}
+
+void
+GMPRemoveTest::Setup()
+{
+  // Initialize media preferences.
+  MediaPrefs::GetSingleton();
+  GeneratePlugin();
+  GetService()->GetThread(getter_AddRefs(mGMPThread));
+
+  // Spin the event loop until the GMP service has had a chance to complete
+  // adding GMPs from MOZ_GMP_PATH. Otherwise, the RemovePluginDirectory()
+  // below may complete before we're finished adding GMPs from MOZ_GMP_PATH,
+  // and we'll end up not removing the GMP, and the test will fail.
+  RefPtr<AbstractThread> thread(GetServiceParent()->GetAbstractGMPThread());
+  EXPECT_TRUE(thread);
+  GMPTestMonitor* mon = &mTestMonitor;
+  GetServiceParent()->EnsureInitialized()->Then(thread, __func__,
+    [mon]() { mon->SetFinished(); },
+    [mon]() { mon->SetFinished(); }
+  );
+  mTestMonitor.AwaitFinished();
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  obs->AddObserver(this, GMP_DELETED_TOPIC, false /* strong ref */);
+  EXPECT_OK(GetServiceParent()->RemovePluginDirectory(mOriginalPath));
+
+  GetServiceParent()->AsyncAddPluginDirectory(mTmpPath)->Then(thread, __func__,
+    [mon]() { mon->SetFinished(); },
+    [mon]() { mon->SetFinished(); }
+  );
+  mTestMonitor.AwaitFinished();
+}
+
+bool
+GMPRemoveTest::CreateVideoDecoder(nsCString aNodeId)
+{
+  GMPVideoHost* host;
+  GMPVideoDecoderProxy* decoder = nullptr;
+
+  mGMPThread->Dispatch(
+    NewNonOwningRunnableMethod<nsCString, GMPVideoDecoderProxy**, GMPVideoHost**>(
+      this, &GMPRemoveTest::gmp_GetVideoDecoder, aNodeId, &decoder, &host),
+    NS_DISPATCH_NORMAL);
+
+  mTestMonitor.AwaitFinished();
+
+  if (!decoder) {
+    return false;
+  }
+
+  GMPVideoCodec codec;
+  memset(&codec, 0, sizeof(codec));
+  codec.mGMPApiVersion = 33;
+
+  nsTArray<uint8_t> empty;
+  mGMPThread->Dispatch(
+    NewNonOwningRunnableMethod<const GMPVideoCodec&, const nsTArray<uint8_t>&, GMPVideoDecoderCallbackProxy*, int32_t>(
+      decoder, &GMPVideoDecoderProxy::InitDecode,
+      codec, empty, this, 1 /* core count */),
+    NS_DISPATCH_SYNC);
+
+  if (mDecoder) {
+    CloseVideoDecoder();
+  }
+
+  mDecoder = decoder;
+  mHost = host;
+
+  return true;
+}
+
+void
+GMPRemoveTest::gmp_GetVideoDecoder(nsCString aNodeId,
+                                   GMPVideoDecoderProxy** aOutDecoder,
+                                   GMPVideoHost** aOutHost)
+{
+  nsTArray<nsCString> tags;
+  tags.AppendElement(NS_LITERAL_CSTRING("h264"));
+  tags.AppendElement(NS_LITERAL_CSTRING("fake"));
+
+  class Callback : public GetGMPVideoDecoderCallback
+  {
+  public:
+    Callback(GMPTestMonitor* aMonitor, GMPVideoDecoderProxy** aDecoder, GMPVideoHost** aHost)
+      : mMonitor(aMonitor), mDecoder(aDecoder), mHost(aHost) { }
+    virtual void Done(GMPVideoDecoderProxy* aDecoder, GMPVideoHost* aHost) override {
+      *mDecoder = aDecoder;
+      *mHost = aHost;
+      mMonitor->SetFinished();
+    }
+  private:
+    GMPTestMonitor* mMonitor;
+    GMPVideoDecoderProxy** mDecoder;
+    GMPVideoHost** mHost;
+  };
+
+  UniquePtr<GetGMPVideoDecoderCallback>
+    cb(new Callback(&mTestMonitor, aOutDecoder, aOutHost));
+
+  if (NS_FAILED(GetService()->GetGMPVideoDecoder(nullptr, &tags, aNodeId, Move(cb)))) {
+    mTestMonitor.SetFinished();
+  }
+}
+
+void
+GMPRemoveTest::CloseVideoDecoder()
+{
+  mGMPThread->Dispatch(
+    NewNonOwningRunnableMethod(mDecoder, &GMPVideoDecoderProxy::Close),
+    NS_DISPATCH_SYNC);
+
+  mDecoder = nullptr;
+  mHost = nullptr;
+}
+
+void
+GMPRemoveTest::DeletePluginDirectory(bool aCanDefer)
+{
+  GetServiceParent()->RemoveAndDeletePluginDirectory(mTmpPath, aCanDefer);
+}
+
+GMPErr
+GMPRemoveTest::Decode()
+{
+  mGMPThread->Dispatch(
+    NewNonOwningRunnableMethod(this, &GMPRemoveTest::gmp_Decode),
+    NS_DISPATCH_NORMAL);
+
+  mTestMonitor.AwaitFinished();
+  return mDecodeResult;
+}
+
+void
+GMPRemoveTest::gmp_Decode()
+{
+  // from gmp-fake.cpp
+  struct EncodedFrame {
+    uint32_t length_;
+    uint8_t h264_compat_;
+    uint32_t magic_;
+    uint32_t width_;
+    uint32_t height_;
+    uint8_t y_;
+    uint8_t u_;
+    uint8_t v_;
+    uint32_t timestamp_;
+  };
+
+  GMPVideoFrame* absFrame;
+  GMPErr err = mHost->CreateFrame(kGMPEncodedVideoFrame, &absFrame);
+  EXPECT_EQ(err, GMPNoErr);
+
+  GMPUniquePtr<GMPVideoEncodedFrame>
+    frame(static_cast<GMPVideoEncodedFrame*>(absFrame));
+  err = frame->CreateEmptyFrame(sizeof(EncodedFrame) /* size */);
+  EXPECT_EQ(err, GMPNoErr);
+
+  EncodedFrame* frameData = reinterpret_cast<EncodedFrame*>(frame->Buffer());
+  frameData->magic_ = 0x4652414d;
+  frameData->width_ = frameData->height_ = 16;
+
+  nsTArray<uint8_t> empty;
+  nsresult rv = mDecoder->Decode(Move(frame), false /* aMissingFrames */, empty);
+  EXPECT_OK(rv);
+}
+
+void
+GMPRemoveTest::Wait()
+{
+  mTestMonitor.AwaitFinished();
+}
+
+bool
+GMPRemoveTest::IsTerminated()
+{
+  return mIsTerminated;
+}
+
+// nsIObserver
+NS_IMETHODIMP
+GMPRemoveTest::Observe(nsISupports* aSubject, const char* aTopic,
+                       const char16_t* aData)
+{
+  EXPECT_TRUE(!strcmp(GMP_DELETED_TOPIC, aTopic));
+
+  nsString data(aData);
+  if (mTmpPath.Equals(data)) {
+    mTestMonitor.SetFinished();
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    obs->RemoveObserver(this, GMP_DELETED_TOPIC);
+  }
+
+  return NS_OK;
+}
+
+// GMPVideoDecoderCallbackProxy
+void
+GMPRemoveTest::Decoded(GMPVideoi420Frame* aDecodedFrame)
+{
+  aDecodedFrame->Destroy();
+  mDecodeResult = GMPNoErr;
+  mTestMonitor.SetFinished();
+}
+
+// GMPVideoDecoderCallbackProxy
+void
+GMPRemoveTest::Error(GMPErr aError)
+{
+  mDecodeResult = aError;
+  mTestMonitor.SetFinished();
+}
+
+// GMPVideoDecoderCallbackProxy
+void
+GMPRemoveTest::Terminated()
+{
+  mIsTerminated = true;
+  if (mDecoder) {
+    mDecoder->Close();
+    mDecoder = nullptr;
+  }
+}
+
+void
+GMPRemoveTest::GeneratePlugin()
+{
+  nsresult rv;
+  nsCOMPtr<nsIFile> gmpDir;
+  nsCOMPtr<nsIFile> origDir;
+  nsCOMPtr<nsIFile> tmpDir;
+
+  rv = NS_GetSpecialDirectory(NS_GRE_DIR,
+                              getter_AddRefs(gmpDir));
+  EXPECT_OK(rv);
+  rv = gmpDir->Append(GMP_DIR_NAME);
+  EXPECT_OK(rv);
+
+  rv = gmpDir->Clone(getter_AddRefs(origDir));
+  EXPECT_OK(rv);
+  rv = origDir->Append(GMP_OLD_VERSION);
+  EXPECT_OK(rv);
+
+  rv = gmpDir->Clone(getter_AddRefs(tmpDir));
+  EXPECT_OK(rv);
+  rv = tmpDir->Append(GMP_NEW_VERSION);
+  EXPECT_OK(rv);
+  bool exists = false;
+  rv = tmpDir->Exists(&exists);
+  EXPECT_OK(rv);
+  if (exists) {
+    rv = tmpDir->Remove(true);
+    EXPECT_OK(rv);
+  }
+  rv = origDir->CopyTo(gmpDir, GMP_NEW_VERSION);
+  EXPECT_OK(rv);
+
+  rv = gmpDir->Clone(getter_AddRefs(tmpDir));
+  EXPECT_OK(rv);
+  rv = tmpDir->Append(GMP_NEW_VERSION);
+  EXPECT_OK(rv);
+
+  EXPECT_OK(origDir->GetPath(mOriginalPath));
+  EXPECT_OK(tmpDir->GetPath(mTmpPath));
+  mTmpDir = tmpDir;
+}
diff --git a/dom/media/gtest/TestGMPUtils.cpp b/dom/media/gtest/TestGMPUtils.cpp
new file mode 100644
index 000000000..75d7eba53
--- /dev/null
+++ b/dom/media/gtest/TestGMPUtils.cpp
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "GMPUtils.h"
+#include "nsString.h"
+#include "MediaPrefs.h"
+
+#include <string>
+#include <vector>
+
+using namespace std;
+using namespace mozilla;
+
+void TestSplitAt(const char* aInput,
+                 const char* aDelims,
+                 size_t aNumExpectedTokens,
+                 const char* aExpectedTokens[])
+{
+  // Initialize media preferences.
+  MediaPrefs::GetSingleton();
+  nsCString input(aInput);
+  nsTArray<nsCString> tokens;
+  SplitAt(aDelims, input, tokens);
+  EXPECT_EQ(tokens.Length(), aNumExpectedTokens) << "Should get expected number of tokens";
+  for (size_t i = 0; i < tokens.Length(); i++) {
+    EXPECT_TRUE(tokens[i].EqualsASCII(aExpectedTokens[i]))
+      << "Tokenize fail; expected=" << aExpectedTokens[i] << " got=" <<
+      tokens[i].BeginReading();
+  }    
+}
+
+TEST(GeckoMediaPlugins, GMPUtils) {
+  {
+    const char* input = "1,2,3,4";
+    const char* delims = ",";
+    const char* tokens[] = { "1", "2", "3", "4" };
+    TestSplitAt(input, delims, MOZ_ARRAY_LENGTH(tokens), tokens);
+  }
+
+  {
+    const char* input = "a simple, comma, seperated, list";
+    const char* delims = ",";
+    const char* tokens[] = { "a simple", " comma", " seperated", " list" };
+    TestSplitAt(input, delims, MOZ_ARRAY_LENGTH(tokens), tokens);
+  }
+
+  {
+    const char* input = // Various platform line endings...
+      "line1\r\n" // Windows
+      "line2\r" // Old MacOSX
+      "line3\n" // Unix
+      "line4";
+    const char* delims = "\r\n";
+    const char* tokens[] = { "line1", "line2", "line3", "line4" };
+    TestSplitAt(input, delims, MOZ_ARRAY_LENGTH(tokens), tokens);
+  }
+}
diff --git a/dom/media/gtest/TestIntervalSet.cpp b/dom/media/gtest/TestIntervalSet.cpp
new file mode 100644
index 000000000..b054ba1d2
--- /dev/null
+++ b/dom/media/gtest/TestIntervalSet.cpp
@@ -0,0 +1,821 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "mozilla/dom/TimeRanges.h"
+#include "TimeUnits.h"
+#include "Intervals.h"
+#include <algorithm>
+#include <vector>
+
+using namespace mozilla;
+
+typedef media::Interval<uint8_t> ByteInterval;
+typedef media::Interval<int> IntInterval;
+typedef media::IntervalSet<int> IntIntervals;
+
+ByteInterval CreateByteInterval(int32_t aStart, int32_t aEnd)
+{
+  ByteInterval test(aStart, aEnd);
+  return test;
+}
+
+media::IntervalSet<uint8_t> CreateByteIntervalSet(int32_t aStart, int32_t aEnd)
+{
+  media::IntervalSet<uint8_t> test;
+  test += ByteInterval(aStart, aEnd);
+  return test;
+}
+
+TEST(IntervalSet, Constructors)
+{
+  const int32_t start = 1;
+  const int32_t end = 2;
+  const int32_t fuzz = 0;
+
+  // Compiler exercise.
+  ByteInterval test1(start, end);
+  ByteInterval test2(test1);
+  ByteInterval test3(start, end, fuzz);
+  ByteInterval test4(test3);
+  ByteInterval test5 = CreateByteInterval(start, end);
+
+  media::IntervalSet<uint8_t> blah1(test1);
+  media::IntervalSet<uint8_t> blah2 = blah1;
+  media::IntervalSet<uint8_t> blah3 = blah1 + test1;
+  media::IntervalSet<uint8_t> blah4 = test1 + blah1;
+  media::IntervalSet<uint8_t> blah5 = CreateByteIntervalSet(start, end);
+  (void)test1; (void)test2; (void)test3; (void)test4; (void)test5;
+  (void)blah1; (void)blah2; (void)blah3; (void)blah4; (void)blah5;
+}
+
+media::TimeInterval CreateTimeInterval(int32_t aStart, int32_t aEnd)
+{
+  // Copy constructor test
+  media::Microseconds startus(aStart);
+  media::TimeUnit start(startus);
+  media::TimeUnit end;
+  // operator=  test
+  end = media::Microseconds(aEnd);
+  media::TimeInterval ti(start, end);
+  return ti;
+}
+
+media::TimeIntervals CreateTimeIntervals(int32_t aStart, int32_t aEnd)
+{
+  media::TimeIntervals test;
+  test += CreateTimeInterval(aStart, aEnd);
+  return test;
+}
+
+TEST(IntervalSet, TimeIntervalsConstructors)
+{
+  const media::Microseconds start(1);
+  const media::Microseconds end(2);
+  const media::Microseconds fuzz;
+
+  // Compiler exercise.
+  media::TimeInterval test1(start, end);
+  media::TimeInterval test2(test1);
+  media::TimeInterval test3(start, end, fuzz);
+  media::TimeInterval test4(test3);
+  media::TimeInterval test5 = CreateTimeInterval(start.mValue, end.mValue);
+
+  media::TimeIntervals blah1(test1);
+  media::TimeIntervals blah2(blah1);
+  media::TimeIntervals blah3 = blah1 + test1;
+  media::TimeIntervals blah4 = test1 + blah1;
+  media::TimeIntervals blah5 = CreateTimeIntervals(start.mValue, end.mValue);
+  (void)test1; (void)test2; (void)test3; (void)test4; (void)test5;
+  (void)blah1; (void)blah2; (void)blah3; (void)blah4; (void)blah5;
+
+  media::TimeIntervals i0{media::TimeInterval(media::TimeUnit::FromSeconds(0),
+                                              media::TimeUnit::FromSeconds(0))};
+  EXPECT_EQ(0u, i0.Length()); // Constructing with an empty time interval.
+}
+
+TEST(IntervalSet, Length)
+{
+  IntInterval i(15, 25);
+  EXPECT_EQ(10, i.Length());
+}
+
+TEST(IntervalSet, Intersects)
+{
+  EXPECT_TRUE(IntInterval(1,5).Intersects(IntInterval(3,4)));
+  EXPECT_TRUE(IntInterval(1,5).Intersects(IntInterval(3,7)));
+  EXPECT_TRUE(IntInterval(1,5).Intersects(IntInterval(-1,3)));
+  EXPECT_TRUE(IntInterval(1,5).Intersects(IntInterval(-1,7)));
+  EXPECT_FALSE(IntInterval(1,5).Intersects(IntInterval(6,7)));
+  EXPECT_FALSE(IntInterval(1,5).Intersects(IntInterval(-1,0)));
+  // End boundary is exclusive of the interval.
+  EXPECT_FALSE(IntInterval(1,5).Intersects(IntInterval(5,7)));
+  EXPECT_FALSE(IntInterval(1,5).Intersects(IntInterval(0,1)));
+  // Empty identical interval do not intersect.
+  EXPECT_FALSE(IntInterval(1,1).Intersects(IntInterval(1,1)));
+  // Empty interval do not intersect.
+  EXPECT_FALSE(IntInterval(1,1).Intersects(IntInterval(2,2)));
+}
+
+TEST(IntervalSet, Intersection)
+{
+  IntInterval i0(10, 20);
+  IntInterval i1(15, 25);
+  IntInterval i = i0.Intersection(i1);
+  EXPECT_EQ(15, i.mStart);
+  EXPECT_EQ(20, i.mEnd);
+  IntInterval j0(10, 20);
+  IntInterval j1(20, 25);
+  IntInterval j = j0.Intersection(j1);
+  EXPECT_TRUE(j.IsEmpty());
+  IntInterval k0(2, 2);
+  IntInterval k1(2, 2);
+  IntInterval k = k0.Intersection(k1);
+  EXPECT_TRUE(k.IsEmpty());
+}
+
+TEST(IntervalSet, Equals)
+{
+  IntInterval i0(10, 20);
+  IntInterval i1(10, 20);
+  EXPECT_EQ(i0, i1);
+
+  IntInterval i2(5, 20);
+  EXPECT_NE(i0, i2);
+
+  IntInterval i3(10, 15);
+  EXPECT_NE(i0, i2);
+}
+
+TEST(IntervalSet, IntersectionIntervalSet)
+{
+  IntIntervals i0;
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+
+  IntIntervals i1;
+  i1.Add(IntInterval(7, 15));
+  i1.Add(IntInterval(16, 27));
+  i1.Add(IntInterval(45, 50));
+  i1.Add(IntInterval(53, 57));
+
+  IntIntervals i = media::Intersection(i0, i1);
+
+  EXPECT_EQ(4u, i.Length());
+
+  EXPECT_EQ(7, i[0].mStart);
+  EXPECT_EQ(10, i[0].mEnd);
+
+  EXPECT_EQ(20, i[1].mStart);
+  EXPECT_EQ(25, i[1].mEnd);
+
+  EXPECT_EQ(45, i[2].mStart);
+  EXPECT_EQ(50, i[2].mEnd);
+
+  EXPECT_EQ(53, i[3].mStart);
+  EXPECT_EQ(57, i[3].mEnd);
+}
+
+template<typename T>
+static void Compare(const media::IntervalSet<T>& aI1,
+                    const media::IntervalSet<T>& aI2)
+{
+  EXPECT_EQ(aI1.Length(), aI2.Length());
+  if (aI1.Length() != aI2.Length()) {
+    return;
+  }
+  for (uint32_t i = 0; i < aI1.Length(); i++) {
+    EXPECT_EQ(aI1[i].mStart, aI2[i].mStart);
+    EXPECT_EQ(aI1[i].mEnd, aI2[i].mEnd);
+  }
+}
+
+static void GeneratePermutations(IntIntervals aI1,
+                                 IntIntervals aI2)
+{
+  IntIntervals i_ref = media::Intersection(aI1, aI2);
+  // Test all permutations possible
+  std::vector<uint32_t> comb1;
+  for (uint32_t i = 0; i < aI1.Length(); i++) {
+    comb1.push_back(i);
+  }
+  std::vector<uint32_t> comb2;
+  for (uint32_t i = 0; i < aI2.Length(); i++) {
+    comb2.push_back(i);
+  }
+
+  do {
+    do {
+      // Create intervals according to new indexes.
+      IntIntervals i_0;
+      for (uint32_t i = 0; i < comb1.size(); i++) {
+        i_0 += aI1[comb1[i]];
+      }
+      // Test that intervals are always normalized.
+      Compare(aI1, i_0);
+      IntIntervals i_1;
+      for (uint32_t i = 0; i < comb2.size(); i++) {
+        i_1 += aI2[comb2[i]];
+      }
+      Compare(aI2, i_1);
+      // Check intersections yield the same result.
+      Compare(i_0.Intersection(i_1), i_ref);
+    } while (std::next_permutation(comb2.begin(), comb2.end()));
+  } while (std::next_permutation(comb1.begin(), comb1.end()));
+}
+
+TEST(IntervalSet, IntersectionNormalizedIntervalSet)
+{
+  IntIntervals i0;
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+
+  IntIntervals i1;
+  i1.Add(IntInterval(7, 15));
+  i1.Add(IntInterval(16, 27));
+  i1.Add(IntInterval(45, 50));
+  i1.Add(IntInterval(53, 57));
+
+  GeneratePermutations(i0, i1);
+}
+
+TEST(IntervalSet, IntersectionUnorderedNonNormalizedIntervalSet)
+{
+  IntIntervals i0;
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(8, 25);
+  i0 += IntInterval(24, 60);
+
+  IntIntervals i1;
+  i1.Add(IntInterval(7, 15));
+  i1.Add(IntInterval(10, 27));
+  i1.Add(IntInterval(45, 50));
+  i1.Add(IntInterval(53, 57));
+
+  GeneratePermutations(i0, i1);
+}
+
+TEST(IntervalSet, IntersectionNonNormalizedInterval)
+{
+  IntIntervals i0;
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(8, 25);
+  i0 += IntInterval(30, 60);
+
+  media::Interval<int> i1(9, 15);
+  i0.Intersection(i1);
+  EXPECT_EQ(1u, i0.Length());
+  EXPECT_EQ(i0[0].mStart, i1.mStart);
+  EXPECT_EQ(i0[0].mEnd, i1.mEnd);
+}
+
+TEST(IntervalSet, IntersectionUnorderedNonNormalizedInterval)
+{
+  IntIntervals i0;
+  i0 += IntInterval(1, 3);
+  i0 += IntInterval(1, 10);
+  i0 += IntInterval(9, 12);
+  i0 += IntInterval(12, 15);
+  i0 += IntInterval(8, 25);
+  i0 += IntInterval(30, 60);
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(30, 60);
+
+  media::Interval<int> i1(9, 15);
+  i0.Intersection(i1);
+  EXPECT_EQ(1u, i0.Length());
+  EXPECT_EQ(i0[0].mStart, i1.mStart);
+  EXPECT_EQ(i0[0].mEnd, i1.mEnd);
+}
+
+static IntIntervals Duplicate(const IntIntervals& aValue)
+{
+  IntIntervals value(aValue);
+  return value;
+}
+
+TEST(IntervalSet, Normalize)
+{
+  IntIntervals i;
+  // Test IntervalSet<T> + Interval<T> operator.
+  i = i + IntInterval(20, 30);
+  // Test Internal<T> + IntervalSet<T> operator.
+  i = IntInterval(2, 7) + i;
+  // Test Interval<T> + IntervalSet<T> operator
+  i = IntInterval(1, 8) + i;
+  IntIntervals interval;
+  interval += IntInterval(5, 10);
+  // Test += with rval move.
+  i += Duplicate(interval);
+  // Test = with move and add with move.
+  i = Duplicate(interval) + i;
+
+  EXPECT_EQ(2u, i.Length());
+
+  EXPECT_EQ(1, i[0].mStart);
+  EXPECT_EQ(10, i[0].mEnd);
+
+  EXPECT_EQ(20, i[1].mStart);
+  EXPECT_EQ(30, i[1].mEnd);
+
+  media::TimeIntervals ti;
+  ti += media::TimeInterval(media::TimeUnit::FromSeconds(0.0),
+                            media::TimeUnit::FromSeconds(3.203333));
+  ti += media::TimeInterval(media::TimeUnit::FromSeconds(3.203366),
+                            media::TimeUnit::FromSeconds(10.010065));
+  EXPECT_EQ(2u, ti.Length());
+  ti += media::TimeInterval(ti.Start(0), ti.End(0), media::TimeUnit::FromMicroseconds(35000));
+  EXPECT_EQ(1u, ti.Length());
+}
+
+TEST(IntervalSet, ContainValue)
+{
+  IntIntervals i0;
+  i0 += IntInterval(0, 10);
+  i0 += IntInterval(15, 20);
+  i0 += IntInterval(30, 50);
+  EXPECT_TRUE(i0.Contains(0)); // start is inclusive.
+  EXPECT_TRUE(i0.Contains(17));
+  EXPECT_FALSE(i0.Contains(20)); // end boundary is exclusive.
+  EXPECT_FALSE(i0.Contains(25));
+}
+
+TEST(IntervalSet, ContainValueWithFuzz)
+{
+  IntIntervals i0;
+  i0 += IntInterval(0, 10);
+  i0 += IntInterval(15, 20, 1);
+  i0 += IntInterval(30, 50);
+  EXPECT_TRUE(i0.Contains(0)); // start is inclusive.
+  EXPECT_TRUE(i0.Contains(17));
+  EXPECT_TRUE(i0.Contains(20)); // end boundary is exclusive but we have a fuzz of 1.
+  EXPECT_FALSE(i0.Contains(25));
+}
+
+TEST(IntervalSet, ContainInterval)
+{
+  IntIntervals i0;
+  i0 += IntInterval(0, 10);
+  i0 += IntInterval(15, 20);
+  i0 += IntInterval(30, 50);
+  EXPECT_TRUE(i0.Contains(IntInterval(2, 8)));
+  EXPECT_TRUE(i0.Contains(IntInterval(31, 50)));
+  EXPECT_TRUE(i0.Contains(IntInterval(0, 10)));
+  EXPECT_FALSE(i0.Contains(IntInterval(0, 11)));
+  EXPECT_TRUE(i0.Contains(IntInterval(0, 5)));
+  EXPECT_FALSE(i0.Contains(IntInterval(8, 15)));
+  EXPECT_FALSE(i0.Contains(IntInterval(15, 30)));
+  EXPECT_FALSE(i0.Contains(IntInterval(30, 55)));
+}
+
+TEST(IntervalSet, ContainIntervalWithFuzz)
+{
+  IntIntervals i0;
+  i0 += IntInterval(0, 10);
+  i0 += IntInterval(15, 20);
+  i0 += IntInterval(30, 50);
+  EXPECT_TRUE(i0.Contains(IntInterval(2, 8)));
+  EXPECT_TRUE(i0.Contains(IntInterval(31, 50)));
+  EXPECT_TRUE(i0.Contains(IntInterval(0, 11, 1)));
+  EXPECT_TRUE(i0.Contains(IntInterval(0, 5)));
+  EXPECT_FALSE(i0.Contains(IntInterval(8, 15)));
+  EXPECT_FALSE(i0.Contains(IntInterval(15, 21)));
+  EXPECT_FALSE(i0.Contains(IntInterval(15, 30)));
+  EXPECT_FALSE(i0.Contains(IntInterval(30, 55)));
+
+  IntIntervals i1;
+  i1 += IntInterval(0, 10, 1);
+  i1 += IntInterval(15, 20, 1);
+  i1 += IntInterval(30, 50, 1);
+  EXPECT_TRUE(i1.Contains(IntInterval(2, 8)));
+  EXPECT_TRUE(i1.Contains(IntInterval(29, 51)));
+  EXPECT_TRUE(i1.Contains(IntInterval(0, 11, 1)));
+  EXPECT_TRUE(i1.Contains(IntInterval(15, 21)));
+}
+
+TEST(IntervalSet, Span)
+{
+  IntInterval i0(0,10);
+  IntInterval i1(20,30);
+  IntInterval i{i0.Span(i1)};
+
+  EXPECT_EQ(i.mStart, 0);
+  EXPECT_EQ(i.mEnd, 30);
+}
+
+TEST(IntervalSet, Union)
+{
+  IntIntervals i0;
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+
+  IntIntervals i1;
+  i1.Add(IntInterval(7, 15));
+  i1.Add(IntInterval(16, 27));
+  i1.Add(IntInterval(45, 50));
+  i1.Add(IntInterval(53, 57));
+
+  IntIntervals i = media::Union(i0, i1);
+
+  EXPECT_EQ(3u, i.Length());
+
+  EXPECT_EQ(5, i[0].mStart);
+  EXPECT_EQ(15, i[0].mEnd);
+
+  EXPECT_EQ(16, i[1].mStart);
+  EXPECT_EQ(27, i[1].mEnd);
+
+  EXPECT_EQ(40, i[2].mStart);
+  EXPECT_EQ(60, i[2].mEnd);
+}
+
+TEST(IntervalSet, UnionNotOrdered)
+{
+  IntIntervals i0;
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+  i0 += IntInterval(5, 10);
+
+  IntIntervals i1;
+  i1.Add(IntInterval(16, 27));
+  i1.Add(IntInterval(7, 15));
+  i1.Add(IntInterval(53, 57));
+  i1.Add(IntInterval(45, 50));
+
+  IntIntervals i = media::Union(i0, i1);
+
+  EXPECT_EQ(3u, i.Length());
+
+  EXPECT_EQ(5, i[0].mStart);
+  EXPECT_EQ(15, i[0].mEnd);
+
+  EXPECT_EQ(16, i[1].mStart);
+  EXPECT_EQ(27, i[1].mEnd);
+
+  EXPECT_EQ(40, i[2].mStart);
+  EXPECT_EQ(60, i[2].mEnd);
+}
+
+TEST(IntervalSet, NormalizeFuzz)
+{
+  IntIntervals i0;
+  i0 += IntInterval(11, 25, 0);
+  i0 += IntInterval(5, 10, 1);
+  i0 += IntInterval(40, 60, 1);
+
+  EXPECT_EQ(2u, i0.Length());
+
+  EXPECT_EQ(5, i0[0].mStart);
+  EXPECT_EQ(25, i0[0].mEnd);
+
+  EXPECT_EQ(40, i0[1].mStart);
+  EXPECT_EQ(60, i0[1].mEnd);
+}
+
+TEST(IntervalSet, UnionFuzz)
+{
+  IntIntervals i0;
+  i0 += IntInterval(5, 10, 1);
+  i0 += IntInterval(11, 25, 0);
+  i0 += IntInterval(40, 60, 1);
+  EXPECT_EQ(2u, i0.Length());
+  EXPECT_EQ(5, i0[0].mStart);
+  EXPECT_EQ(25, i0[0].mEnd);
+  EXPECT_EQ(40, i0[1].mStart);
+  EXPECT_EQ(60, i0[1].mEnd);
+
+  IntIntervals i1;
+  i1.Add(IntInterval(7, 15, 1));
+  i1.Add(IntInterval(16, 27, 1));
+  i1.Add(IntInterval(45, 50, 1));
+  i1.Add(IntInterval(53, 57, 1));
+  EXPECT_EQ(3u, i1.Length());
+  EXPECT_EQ(7, i1[0].mStart);
+  EXPECT_EQ(27, i1[0].mEnd);
+  EXPECT_EQ(45, i1[1].mStart);
+  EXPECT_EQ(50, i1[1].mEnd);
+  EXPECT_EQ(53, i1[2].mStart);
+  EXPECT_EQ(57, i1[2].mEnd);
+
+  IntIntervals i = media::Union(i0, i1);
+
+  EXPECT_EQ(2u, i.Length());
+
+  EXPECT_EQ(5, i[0].mStart);
+  EXPECT_EQ(27, i[0].mEnd);
+
+  EXPECT_EQ(40, i[1].mStart);
+  EXPECT_EQ(60, i[1].mEnd);
+}
+
+TEST(IntervalSet, Contiguous)
+{
+  EXPECT_FALSE(IntInterval(5, 10).Contiguous(IntInterval(11, 25)));
+  EXPECT_TRUE(IntInterval(5, 10).Contiguous(IntInterval(10, 25)));
+  EXPECT_TRUE(IntInterval(5, 10, 1).Contiguous(IntInterval(11, 25)));
+  EXPECT_TRUE(IntInterval(5, 10).Contiguous(IntInterval(11, 25, 1)));
+}
+
+TEST(IntervalSet, TimeRangesSeconds)
+{
+  media::TimeIntervals i0;
+  i0 += media::TimeInterval(media::TimeUnit::FromSeconds(20), media::TimeUnit::FromSeconds(25));
+  i0 += media::TimeInterval(media::TimeUnit::FromSeconds(40), media::TimeUnit::FromSeconds(60));
+  i0 += media::TimeInterval(media::TimeUnit::FromSeconds(5), media::TimeUnit::FromSeconds(10));
+
+  media::TimeIntervals i1;
+  i1.Add(media::TimeInterval(media::TimeUnit::FromSeconds(16), media::TimeUnit::FromSeconds(27)));
+  i1.Add(media::TimeInterval(media::TimeUnit::FromSeconds(7), media::TimeUnit::FromSeconds(15)));
+  i1.Add(media::TimeInterval(media::TimeUnit::FromSeconds(53), media::TimeUnit::FromSeconds(57)));
+  i1.Add(media::TimeInterval(media::TimeUnit::FromSeconds(45), media::TimeUnit::FromSeconds(50)));
+
+  media::TimeIntervals i(i0 + i1);
+  RefPtr<dom::TimeRanges> tr = new dom::TimeRanges();
+  i.ToTimeRanges(tr);
+  EXPECT_EQ(tr->Length(), i.Length());
+  for (dom::TimeRanges::index_type index = 0; index < tr->Length(); index++) {
+    ErrorResult rv;
+    EXPECT_EQ(tr->Start(index, rv), i[index].mStart.ToSeconds());
+    EXPECT_EQ(tr->Start(index, rv), i.Start(index).ToSeconds());
+    EXPECT_EQ(tr->End(index, rv), i[index].mEnd.ToSeconds());
+    EXPECT_EQ(tr->End(index, rv), i.End(index).ToSeconds());
+  }
+}
+
+static void CheckTimeRanges(dom::TimeRanges* aTr, const media::TimeIntervals& aTi)
+{
+  RefPtr<dom::TimeRanges> tr = new dom::TimeRanges;
+  tr->Union(aTr, 0); // This will normalize the time range.
+  EXPECT_EQ(tr->Length(), aTi.Length());
+  for (dom::TimeRanges::index_type i = 0; i < tr->Length(); i++) {
+    ErrorResult rv;
+    EXPECT_EQ(tr->Start(i, rv), aTi[i].mStart.ToSeconds());
+    EXPECT_EQ(tr->Start(i, rv), aTi.Start(i).ToSeconds());
+    EXPECT_EQ(tr->End(i, rv), aTi[i].mEnd.ToSeconds());
+    EXPECT_EQ(tr->End(i, rv), aTi.End(i).ToSeconds());
+  }
+}
+
+TEST(IntervalSet, TimeRangesConversion)
+{
+  RefPtr<dom::TimeRanges> tr = new dom::TimeRanges();
+  tr->Add(20, 25);
+  tr->Add(40, 60);
+  tr->Add(5, 10);
+  tr->Add(16, 27);
+  tr->Add(53, 57);
+  tr->Add(45, 50);
+
+  // explicit copy constructor
+  media::TimeIntervals i1(tr);
+  CheckTimeRanges(tr, i1);
+
+  // static FromTimeRanges
+  media::TimeIntervals i2 = media::TimeIntervals::FromTimeRanges(tr);
+  CheckTimeRanges(tr, i2);
+
+  media::TimeIntervals i3;
+  // operator=(TimeRanges*)
+  i3 = tr;
+  CheckTimeRanges(tr, i3);
+
+  // operator= test
+  i1 = tr.get();
+  CheckTimeRanges(tr, i1);
+}
+
+TEST(IntervalSet, TimeRangesMicroseconds)
+{
+  media::TimeIntervals i0;
+
+  // Test media::Microseconds and TimeUnit interchangeability (compilation only)
+  media::TimeUnit time1{media::Microseconds(5)};
+  media::Microseconds microseconds(5);
+  media::TimeUnit time2 = media::TimeUnit(microseconds);
+  EXPECT_EQ(time1, time2);
+
+  i0 += media::TimeInterval(media::Microseconds(20), media::Microseconds(25));
+  i0 += media::TimeInterval(media::Microseconds(40), media::Microseconds(60));
+  i0 += media::TimeInterval(media::Microseconds(5), media::Microseconds(10));
+
+  media::TimeIntervals i1;
+  i1.Add(media::TimeInterval(media::Microseconds(16), media::Microseconds(27)));
+  i1.Add(media::TimeInterval(media::Microseconds(7), media::Microseconds(15)));
+  i1.Add(media::TimeInterval(media::Microseconds(53), media::Microseconds(57)));
+  i1.Add(media::TimeInterval(media::Microseconds(45), media::Microseconds(50)));
+
+  media::TimeIntervals i(i0 + i1);
+  RefPtr<dom::TimeRanges> tr = new dom::TimeRanges();
+  i.ToTimeRanges(tr);
+  EXPECT_EQ(tr->Length(), i.Length());
+  for (dom::TimeRanges::index_type index = 0; index < tr->Length(); index++) {
+    ErrorResult rv;
+    EXPECT_EQ(tr->Start(index, rv), i[index].mStart.ToSeconds());
+    EXPECT_EQ(tr->Start(index, rv), i.Start(index).ToSeconds());
+    EXPECT_EQ(tr->End(index, rv), i[index].mEnd.ToSeconds());
+    EXPECT_EQ(tr->End(index, rv), i.End(index).ToSeconds());
+  }
+
+  tr->Normalize();
+  EXPECT_EQ(tr->Length(), i.Length());
+  for (dom::TimeRanges::index_type index = 0; index < tr->Length(); index++) {
+    ErrorResult rv;
+    EXPECT_EQ(tr->Start(index, rv), i[index].mStart.ToSeconds());
+    EXPECT_EQ(tr->Start(index, rv), i.Start(index).ToSeconds());
+    EXPECT_EQ(tr->End(index, rv), i[index].mEnd.ToSeconds());
+    EXPECT_EQ(tr->End(index, rv), i.End(index).ToSeconds());
+  }
+
+  // Check infinity values aren't lost in the conversion.
+  tr = new dom::TimeRanges();
+  tr->Add(0, 30);
+  tr->Add(50, std::numeric_limits<double>::infinity());
+  media::TimeIntervals i_oo{media::TimeIntervals::FromTimeRanges(tr)};
+  RefPtr<dom::TimeRanges> tr2 = new dom::TimeRanges();
+  i_oo.ToTimeRanges(tr2);
+  EXPECT_EQ(tr->Length(), tr2->Length());
+  for (dom::TimeRanges::index_type index = 0; index < tr->Length(); index++) {
+    ErrorResult rv;
+    EXPECT_EQ(tr->Start(index, rv), tr2->Start(index, rv));
+    EXPECT_EQ(tr->End(index, rv), tr2->End(index, rv));
+  }
+}
+
+template<typename T>
+class Foo
+{
+public:
+  Foo()
+    : mArg1(1)
+    , mArg2(2)
+    , mArg3(3)
+  {}
+
+  Foo(T a1, T a2, T a3)
+    : mArg1(a1)
+    , mArg2(a2)
+    , mArg3(a3)
+  {}
+
+  Foo<T> operator+ (const Foo<T>& aOther) const
+  {
+    Foo<T> blah;
+    blah.mArg1 += aOther.mArg1;
+    blah.mArg2 += aOther.mArg2;
+    blah.mArg3 += aOther.mArg3;
+    return blah;
+  }
+  Foo<T> operator- (const Foo<T>& aOther) const
+  {
+    Foo<T> blah;
+    blah.mArg1 -= aOther.mArg1;
+    blah.mArg2 -= aOther.mArg2;
+    blah.mArg3 -= aOther.mArg3;
+    return blah;
+  }
+  bool operator< (const Foo<T>& aOther) const
+  {
+    return mArg1 < aOther.mArg1;
+  }
+  bool operator== (const Foo<T>& aOther) const
+  {
+    return mArg1 == aOther.mArg1;
+  }
+  bool operator<= (const Foo<T>& aOther) const
+  {
+    return mArg1 <= aOther.mArg1;
+  }
+
+private:
+  int32_t mArg1;
+  int32_t mArg2;
+  int32_t mArg3;
+};
+
+TEST(IntervalSet, FooIntervalSet)
+{
+  media::Interval<Foo<int>> i(Foo<int>(), Foo<int>(4,5,6));
+  media::IntervalSet<Foo<int>> is;
+  is += i;
+  is += i;
+  is.Add(i);
+  is = is + i;
+  is = i + is;
+  EXPECT_EQ(1u, is.Length());
+  EXPECT_EQ(Foo<int>(), is[0].mStart);
+  EXPECT_EQ(Foo<int>(4,5,6), is[0].mEnd);
+}
+
+TEST(IntervalSet, StaticAssert)
+{
+  media::Interval<int> i;
+
+  static_assert(mozilla::IsSame<nsTArray_CopyChooser<IntIntervals>::Type, nsTArray_CopyWithConstructors<IntIntervals>>::value, "Must use copy constructor");
+  static_assert(mozilla::IsSame<nsTArray_CopyChooser<media::TimeIntervals>::Type, nsTArray_CopyWithConstructors<media::TimeIntervals>>::value, "Must use copy constructor");
+}
+
+TEST(IntervalSet, Substraction)
+{
+  IntIntervals i0;
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+
+  IntInterval i1(8, 15);
+  i0 -= i1;
+
+  EXPECT_EQ(3u, i0.Length());
+  EXPECT_EQ(5, i0[0].mStart);
+  EXPECT_EQ(8, i0[0].mEnd);
+  EXPECT_EQ(20, i0[1].mStart);
+  EXPECT_EQ(25, i0[1].mEnd);
+  EXPECT_EQ(40, i0[2].mStart);
+  EXPECT_EQ(60, i0[2].mEnd);
+
+  i0 = IntIntervals();
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+  i1 = IntInterval(0, 60);
+  i0 -= i1;
+  EXPECT_EQ(0u, i0.Length());
+
+  i0 = IntIntervals();
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+  i1 = IntInterval(0, 45);
+  i0 -= i1;
+  EXPECT_EQ(1u, i0.Length());
+  EXPECT_EQ(45, i0[0].mStart);
+  EXPECT_EQ(60, i0[0].mEnd);
+
+  i0 = IntIntervals();
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+  i1 = IntInterval(8, 45);
+  i0 -= i1;
+  EXPECT_EQ(2u, i0.Length());
+  EXPECT_EQ(5, i0[0].mStart);
+  EXPECT_EQ(8, i0[0].mEnd);
+  EXPECT_EQ(45, i0[1].mStart);
+  EXPECT_EQ(60, i0[1].mEnd);
+
+  i0 = IntIntervals();
+  i0 += IntInterval(5, 10);
+  i0 += IntInterval(20, 25);
+  i0 += IntInterval(40, 60);
+  i1 = IntInterval(8, 70);
+  i0 -= i1;
+  EXPECT_EQ(1u, i0.Length());
+  EXPECT_EQ(5, i0[0].mStart);
+  EXPECT_EQ(8, i0[0].mEnd);
+
+  i0 = IntIntervals();
+  i0 += IntInterval(0, 10);
+  IntIntervals i2;
+  i2 += IntInterval(4, 6);
+  i0 -= i2;
+  EXPECT_EQ(2u, i0.Length());
+  EXPECT_EQ(0, i0[0].mStart);
+  EXPECT_EQ(4, i0[0].mEnd);
+  EXPECT_EQ(6, i0[1].mStart);
+  EXPECT_EQ(10, i0[1].mEnd);
+
+  i0 = IntIntervals();
+  i0 += IntInterval(0, 1);
+  i0 += IntInterval(3, 10);
+  EXPECT_EQ(2u, i0.Length());
+  // This fuzz should collapse i0 into [0,10).
+  i0.SetFuzz(1);
+  EXPECT_EQ(1u, i0.Length());
+  EXPECT_EQ(1, i0[0].mFuzz);
+  i2 = IntInterval(4, 6);
+  i0 -= i2;
+  EXPECT_EQ(2u, i0.Length());
+  EXPECT_EQ(0, i0[0].mStart);
+  EXPECT_EQ(4, i0[0].mEnd);
+  EXPECT_EQ(6, i0[1].mStart);
+  EXPECT_EQ(10, i0[1].mEnd);
+  EXPECT_EQ(1, i0[0].mFuzz);
+  EXPECT_EQ(1, i0[1].mFuzz);
+
+  i0 = IntIntervals();
+  i0 += IntInterval(0, 10);
+  // [4,6) with fuzz 1 used to fail because the complementary interval set
+  // [0,4)+[6,10) would collapse into [0,10).
+  i2 = IntInterval(4, 6);
+  i2.SetFuzz(1);
+  i0 -= i2;
+  EXPECT_EQ(2u, i0.Length());
+  EXPECT_EQ(0, i0[0].mStart);
+  EXPECT_EQ(4, i0[0].mEnd);
+  EXPECT_EQ(6, i0[1].mStart);
+  EXPECT_EQ(10, i0[1].mEnd);
+}
diff --git a/dom/media/gtest/TestMP3Demuxer.cpp b/dom/media/gtest/TestMP3Demuxer.cpp
new file mode 100644
index 000000000..8d2109f00
--- /dev/null
+++ b/dom/media/gtest/TestMP3Demuxer.cpp
@@ -0,0 +1,454 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include <gtest/gtest.h>
+#include <vector>
+
+#include "MP3Demuxer.h"
+#include "mozilla/ArrayUtils.h"
+#include "MockMediaResource.h"
+
+using namespace mozilla;
+using namespace mozilla::mp3;
+using media::TimeUnit;
+
+
+// Regular MP3 file mock resource.
+class MockMP3MediaResource : public MockMediaResource {
+public:
+  explicit MockMP3MediaResource(const char* aFileName)
+    : MockMediaResource(aFileName)
+  {}
+
+protected:
+  virtual ~MockMP3MediaResource() {}
+};
+
+// MP3 stream mock resource.
+class MockMP3StreamMediaResource : public MockMP3MediaResource {
+public:
+  explicit MockMP3StreamMediaResource(const char* aFileName)
+    : MockMP3MediaResource(aFileName)
+  {}
+
+  int64_t GetLength() override { return -1; }
+
+protected:
+  virtual ~MockMP3StreamMediaResource() {}
+};
+
+struct MP3Resource {
+  const char* mFilePath;
+  bool mIsVBR;
+  int64_t mFileSize;
+  int32_t mMPEGLayer;
+  int32_t mMPEGVersion;
+  uint8_t mID3MajorVersion;
+  uint8_t mID3MinorVersion;
+  uint8_t mID3Flags;
+  uint32_t mID3Size;
+
+  int64_t mDuration;
+  float mDurationError;
+  float mSeekError;
+  int32_t mSampleRate;
+  int32_t mSamplesPerFrame;
+  uint32_t mNumSamples;
+  // TODO: temp solution, we could parse them instead or account for them
+  // otherwise.
+  int32_t mNumTrailingFrames;
+  int32_t mBitrate;
+  int32_t mSlotSize;
+  int32_t mPrivate;
+
+  // The first n frame offsets.
+  std::vector<int32_t> mSyncOffsets;
+  RefPtr<MockMP3MediaResource> mResource;
+  RefPtr<MP3TrackDemuxer> mDemuxer;
+};
+
+class MP3DemuxerTest : public ::testing::Test {
+protected:
+  void SetUp() override {
+    {
+      MP3Resource res;
+      res.mFilePath = "noise.mp3";
+      res.mIsVBR = false;
+      res.mFileSize = 965257;
+      res.mMPEGLayer = 3;
+      res.mMPEGVersion = 1;
+      res.mID3MajorVersion = 3;
+      res.mID3MinorVersion = 0;
+      res.mID3Flags = 0;
+      res.mID3Size = 2141;
+      res.mDuration = 30067000;
+      res.mDurationError = 0.001f;
+      res.mSeekError = 0.02f;
+      res.mSampleRate = 44100;
+      res.mSamplesPerFrame = 1152;
+      res.mNumSamples = 1325952;
+      res.mNumTrailingFrames = 2;
+      res.mBitrate = 256000;
+      res.mSlotSize = 1;
+      res.mPrivate = 0;
+      const int syncs[] = { 2151, 2987, 3823, 4659, 5495, 6331 };
+      res.mSyncOffsets.insert(res.mSyncOffsets.begin(), syncs, syncs + 6);
+
+      // No content length can be estimated for CBR stream resources.
+      MP3Resource streamRes = res;
+      streamRes.mFileSize = -1;
+      streamRes.mDuration = -1;
+      streamRes.mDurationError = 0.0f;
+
+      res.mResource = new MockMP3MediaResource(res.mFilePath);
+      res.mDemuxer = new MP3TrackDemuxer(res.mResource);
+      mTargets.push_back(res);
+
+      streamRes.mResource = new MockMP3StreamMediaResource(streamRes.mFilePath);
+      streamRes.mDemuxer = new MP3TrackDemuxer(streamRes.mResource);
+      mTargets.push_back(streamRes);
+    }
+
+    {
+      MP3Resource res;
+      // This file trips up the MP3 demuxer if ID3v2 tags aren't properly skipped. If skipping is
+      // not properly implemented, depending on the strictness of the MPEG frame parser a false
+      // sync will be detected somewhere within the metadata at or after 112087, or failing
+      // that, at the artificially added extraneous header at 114532.
+      res.mFilePath = "id3v2header.mp3";
+      res.mIsVBR = false;
+      res.mFileSize = 191302;
+      res.mMPEGLayer = 3;
+      res.mMPEGVersion = 1;
+      res.mID3MajorVersion = 3;
+      res.mID3MinorVersion = 0;
+      res.mID3Flags = 0;
+      res.mID3Size = 115304;
+      res.mDuration = 3160816;
+      res.mDurationError = 0.001f;
+      res.mSeekError = 0.02f;
+      res.mSampleRate = 44100;
+      res.mSamplesPerFrame = 1152;
+      res.mNumSamples = 139392;
+      res.mNumTrailingFrames = 0;
+      res.mBitrate = 192000;
+      res.mSlotSize = 1;
+      res.mPrivate = 1;
+      const int syncs[] = { 115314, 115941, 116568, 117195, 117822, 118449 };
+      res.mSyncOffsets.insert(res.mSyncOffsets.begin(), syncs, syncs + 6);
+
+      // No content length can be estimated for CBR stream resources.
+      MP3Resource streamRes = res;
+      streamRes.mFileSize = -1;
+      streamRes.mDuration = -1;
+      streamRes.mDurationError = 0.0f;
+
+      res.mResource = new MockMP3MediaResource(res.mFilePath);
+      res.mDemuxer = new MP3TrackDemuxer(res.mResource);
+      mTargets.push_back(res);
+
+      streamRes.mResource = new MockMP3StreamMediaResource(streamRes.mFilePath);
+      streamRes.mDemuxer = new MP3TrackDemuxer(streamRes.mResource);
+      mTargets.push_back(streamRes);
+    }
+
+    {
+      MP3Resource res;
+      res.mFilePath = "noise_vbr.mp3";
+      res.mIsVBR = true;
+      res.mFileSize = 583679;
+      res.mMPEGLayer = 3;
+      res.mMPEGVersion = 1;
+      res.mID3MajorVersion = 3;
+      res.mID3MinorVersion = 0;
+      res.mID3Flags = 0;
+      res.mID3Size = 2221;
+      res.mDuration = 30081000;
+      res.mDurationError = 0.005f;
+      res.mSeekError = 0.02f;
+      res.mSampleRate = 44100;
+      res.mSamplesPerFrame = 1152;
+      res.mNumSamples = 1326575;
+      res.mNumTrailingFrames = 3;
+      res.mBitrate = 154000;
+      res.mSlotSize = 1;
+      res.mPrivate = 0;
+      const int syncs[] = { 2231, 2648, 2752, 3796, 4318, 4735 };
+      res.mSyncOffsets.insert(res.mSyncOffsets.begin(), syncs, syncs + 6);
+
+      // VBR stream resources contain header info on total frames numbers, which
+      // is used to estimate the total duration.
+      MP3Resource streamRes = res;
+      streamRes.mFileSize = -1;
+
+      res.mResource = new MockMP3MediaResource(res.mFilePath);
+      res.mDemuxer = new MP3TrackDemuxer(res.mResource);
+      mTargets.push_back(res);
+
+      streamRes.mResource = new MockMP3StreamMediaResource(streamRes.mFilePath);
+      streamRes.mDemuxer = new MP3TrackDemuxer(streamRes.mResource);
+      mTargets.push_back(streamRes);
+    }
+
+    {
+      MP3Resource res;
+      res.mFilePath = "small-shot.mp3";
+      res.mIsVBR = true;
+      res.mFileSize = 6825;
+      res.mMPEGLayer = 3;
+      res.mMPEGVersion = 1;
+      res.mID3MajorVersion = 4;
+      res.mID3MinorVersion = 0;
+      res.mID3Flags = 0;
+      res.mID3Size = 24;
+      res.mDuration = 336686;
+      res.mDurationError = 0.01f;
+      res.mSeekError = 0.2f;
+      res.mSampleRate = 44100;
+      res.mSamplesPerFrame = 1152;
+      res.mNumSamples = 12;
+      res.mNumTrailingFrames = 0;
+      res.mBitrate = 256000;
+      res.mSlotSize = 1;
+      res.mPrivate = 0;
+      const int syncs[] = { 34, 556, 1078, 1601, 2123, 2646, 3168, 3691, 4213,
+                            4736, 5258, 5781, 6303 };
+      res.mSyncOffsets.insert(res.mSyncOffsets.begin(), syncs, syncs + 13);
+
+      // No content length can be estimated for CBR stream resources.
+      MP3Resource streamRes = res;
+      streamRes.mFileSize = -1;
+
+      res.mResource = new MockMP3MediaResource(res.mFilePath);
+      res.mDemuxer = new MP3TrackDemuxer(res.mResource);
+      mTargets.push_back(res);
+
+      streamRes.mResource = new MockMP3StreamMediaResource(streamRes.mFilePath);
+      streamRes.mDemuxer = new MP3TrackDemuxer(streamRes.mResource);
+      mTargets.push_back(streamRes);
+    }
+
+    {
+      MP3Resource res;
+      // This file contains a false frame sync at 34, just after the ID3 tag,
+      // which should be identified as a false positive and skipped.
+      res.mFilePath = "small-shot-false-positive.mp3";
+      res.mIsVBR = true;
+      res.mFileSize = 6845;
+      res.mMPEGLayer = 3;
+      res.mMPEGVersion = 1;
+      res.mID3MajorVersion = 4;
+      res.mID3MinorVersion = 0;
+      res.mID3Flags = 0;
+      res.mID3Size = 24;
+      res.mDuration = 336686;
+      res.mDurationError = 0.01f;
+      res.mSeekError = 0.2f;
+      res.mSampleRate = 44100;
+      res.mSamplesPerFrame = 1152;
+      res.mNumSamples = 12;
+      res.mNumTrailingFrames = 0;
+      res.mBitrate = 256000;
+      res.mSlotSize = 1;
+      res.mPrivate = 0;
+      const int syncs[] = { 54, 576, 1098, 1621, 2143, 2666, 3188, 3711, 4233,
+        4756, 5278, 5801, 6323 };
+      res.mSyncOffsets.insert(res.mSyncOffsets.begin(), syncs, syncs + 13);
+
+      // No content length can be estimated for CBR stream resources.
+      MP3Resource streamRes = res;
+      streamRes.mFileSize = -1;
+
+      res.mResource = new MockMP3MediaResource(res.mFilePath);
+      res.mDemuxer = new MP3TrackDemuxer(res.mResource);
+      mTargets.push_back(res);
+
+      streamRes.mResource = new MockMP3StreamMediaResource(streamRes.mFilePath);
+      streamRes.mDemuxer = new MP3TrackDemuxer(streamRes.mResource);
+      mTargets.push_back(streamRes);
+    }
+
+    for (auto& target: mTargets) {
+      ASSERT_EQ(NS_OK, target.mResource->Open(nullptr));
+      ASSERT_TRUE(target.mDemuxer->Init());
+    }
+  }
+
+  std::vector<MP3Resource> mTargets;
+};
+
+TEST_F(MP3DemuxerTest, ID3Tags) {
+  for (const auto& target: mTargets) {
+    RefPtr<MediaRawData> frame(target.mDemuxer->DemuxSample());
+    ASSERT_TRUE(frame);
+
+    const auto& id3 = target.mDemuxer->ID3Header();
+    ASSERT_TRUE(id3.IsValid());
+
+    EXPECT_EQ(target.mID3MajorVersion, id3.MajorVersion());
+    EXPECT_EQ(target.mID3MinorVersion, id3.MinorVersion());
+    EXPECT_EQ(target.mID3Flags, id3.Flags());
+    EXPECT_EQ(target.mID3Size, id3.Size());
+  }
+}
+
+TEST_F(MP3DemuxerTest, VBRHeader) {
+  for (const auto& target: mTargets) {
+    RefPtr<MediaRawData> frame(target.mDemuxer->DemuxSample());
+    ASSERT_TRUE(frame);
+
+    const auto& vbr = target.mDemuxer->VBRInfo();
+
+    if (target.mIsVBR) {
+      EXPECT_EQ(FrameParser::VBRHeader::XING, vbr.Type());
+      // TODO: find reference number which accounts for trailing headers.
+      // EXPECT_EQ(target.mNumSamples / target.mSamplesPerFrame, vbr.NumAudioFrames().value());
+    } else {
+      EXPECT_EQ(FrameParser::VBRHeader::NONE, vbr.Type());
+      EXPECT_FALSE(vbr.NumAudioFrames());
+    }
+  }
+}
+
+TEST_F(MP3DemuxerTest, FrameParsing) {
+  for (const auto& target: mTargets) {
+    RefPtr<MediaRawData> frameData(target.mDemuxer->DemuxSample());
+    ASSERT_TRUE(frameData);
+    EXPECT_EQ(target.mFileSize, target.mDemuxer->StreamLength());
+
+    const auto& id3 = target.mDemuxer->ID3Header();
+    ASSERT_TRUE(id3.IsValid());
+
+    int64_t parsedLength = id3.Size();
+    int64_t bitrateSum = 0;
+    int32_t numFrames = 0;
+    int32_t numSamples = 0;
+
+    while (frameData) {
+      if (static_cast<int64_t>(target.mSyncOffsets.size()) > numFrames) {
+        // Test sync offsets.
+        EXPECT_EQ(target.mSyncOffsets[numFrames], frameData->mOffset);
+      }
+
+      ++numFrames;
+      parsedLength += frameData->Size();
+
+      const auto& frame = target.mDemuxer->LastFrame();
+      const auto& header = frame.Header();
+      ASSERT_TRUE(header.IsValid());
+
+      numSamples += header.SamplesPerFrame();
+
+      EXPECT_EQ(target.mMPEGLayer, header.Layer());
+      EXPECT_EQ(target.mSampleRate, header.SampleRate());
+      EXPECT_EQ(target.mSamplesPerFrame, header.SamplesPerFrame());
+      EXPECT_EQ(target.mSlotSize, header.SlotSize());
+      EXPECT_EQ(target.mPrivate, header.Private());
+
+      if (target.mIsVBR) {
+        // Used to compute the average bitrate for VBR streams.
+        bitrateSum += target.mBitrate;
+      } else {
+        EXPECT_EQ(target.mBitrate, header.Bitrate());
+      }
+
+      frameData = target.mDemuxer->DemuxSample();
+    }
+
+    // TODO: find reference number which accounts for trailing headers.
+    // EXPECT_EQ(target.mNumSamples / target.mSamplesPerFrame, numFrames);
+    // EXPECT_EQ(target.mNumSamples, numSamples);
+
+    // There may be trailing headers which we don't parse, so the stream length
+    // is the upper bound.
+    if (target.mFileSize > 0) {
+      EXPECT_GE(target.mFileSize, parsedLength);
+    }
+
+    if (target.mIsVBR) {
+      ASSERT_TRUE(numFrames);
+      EXPECT_EQ(target.mBitrate, static_cast<int32_t>(bitrateSum / numFrames));
+    }
+  }
+}
+
+TEST_F(MP3DemuxerTest, Duration) {
+  for (const auto& target: mTargets) {
+    RefPtr<MediaRawData> frameData(target.mDemuxer->DemuxSample());
+    ASSERT_TRUE(frameData);
+    EXPECT_EQ(target.mFileSize, target.mDemuxer->StreamLength());
+
+    while (frameData) {
+      EXPECT_NEAR(target.mDuration, target.mDemuxer->Duration().ToMicroseconds(),
+                  target.mDurationError * target.mDuration);
+
+      frameData = target.mDemuxer->DemuxSample();
+    }
+  }
+
+  // Seek out of range tests.
+  for (const auto& target: mTargets) {
+    // Skip tests for stream media resources because of lacking duration.
+    if (target.mFileSize <= 0) {
+      continue;
+    }
+
+    target.mDemuxer->Reset();
+    RefPtr<MediaRawData> frameData(target.mDemuxer->DemuxSample());
+    ASSERT_TRUE(frameData);
+
+    const int64_t duration = target.mDemuxer->Duration().ToMicroseconds();
+    const int64_t pos = duration + 1e6;
+
+    // Attempt to seek 1 second past the end of stream.
+    target.mDemuxer->Seek(TimeUnit::FromMicroseconds(pos));
+    // The seek should bring us to the end of the stream.
+    EXPECT_NEAR(duration, target.mDemuxer->SeekPosition().ToMicroseconds(),
+                target.mSeekError * duration);
+
+    // Since we're at the end of the stream, there should be no frames left.
+    frameData = target.mDemuxer->DemuxSample();
+    ASSERT_FALSE(frameData);
+  }
+}
+
+TEST_F(MP3DemuxerTest, Seek) {
+  for (const auto& target: mTargets) {
+    RefPtr<MediaRawData> frameData(target.mDemuxer->DemuxSample());
+    ASSERT_TRUE(frameData);
+
+    const int64_t seekTime = TimeUnit::FromSeconds(1).ToMicroseconds();
+    int64_t pos = target.mDemuxer->SeekPosition().ToMicroseconds();
+
+    while (frameData) {
+      EXPECT_NEAR(pos, target.mDemuxer->SeekPosition().ToMicroseconds(),
+                  target.mSeekError * pos);
+
+      pos += seekTime;
+      target.mDemuxer->Seek(TimeUnit::FromMicroseconds(pos));
+      frameData = target.mDemuxer->DemuxSample();
+    }
+  }
+
+  // Seeking should work with in-between resets, too.
+  for (const auto& target: mTargets) {
+    target.mDemuxer->Reset();
+    RefPtr<MediaRawData> frameData(target.mDemuxer->DemuxSample());
+    ASSERT_TRUE(frameData);
+
+    const int64_t seekTime = TimeUnit::FromSeconds(1).ToMicroseconds();
+    int64_t pos = target.mDemuxer->SeekPosition().ToMicroseconds();
+
+    while (frameData) {
+      EXPECT_NEAR(pos, target.mDemuxer->SeekPosition().ToMicroseconds(),
+                  target.mSeekError * pos);
+
+      pos += seekTime;
+      target.mDemuxer->Reset();
+      target.mDemuxer->Seek(TimeUnit::FromMicroseconds(pos));
+      frameData = target.mDemuxer->DemuxSample();
+    }
+  }
+}
diff --git a/dom/media/gtest/TestMP4Demuxer.cpp b/dom/media/gtest/TestMP4Demuxer.cpp
new file mode 100644
index 000000000..f1210fde7
--- /dev/null
+++ b/dom/media/gtest/TestMP4Demuxer.cpp
@@ -0,0 +1,463 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "MP4Demuxer.h"
+#include "MP4Stream.h"
+#include "mozilla/MozPromise.h"
+#include "MediaDataDemuxer.h"
+#include "mozilla/SharedThreadPool.h"
+#include "mozilla/TaskQueue.h"
+#include "mozilla/ArrayUtils.h"
+#include "MockMediaResource.h"
+#include "VideoUtils.h"
+
+using namespace mozilla;
+using namespace mp4_demuxer;
+
+class AutoTaskQueue;
+
+#define DO_FAIL [binding]()->void { EXPECT_TRUE(false); binding->mTaskQueue->BeginShutdown(); }
+
+class MP4DemuxerBinding
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MP4DemuxerBinding);
+
+  RefPtr<MockMediaResource> resource;
+  RefPtr<MP4Demuxer> mDemuxer;
+  RefPtr<TaskQueue> mTaskQueue;
+  RefPtr<MediaTrackDemuxer> mAudioTrack;
+  RefPtr<MediaTrackDemuxer> mVideoTrack;
+  uint32_t mIndex;
+  nsTArray<RefPtr<MediaRawData>> mSamples;
+  nsTArray<int64_t> mKeyFrameTimecodes;
+  MozPromiseHolder<GenericPromise> mCheckTrackKeyFramePromise;
+  MozPromiseHolder<GenericPromise> mCheckTrackSamples;
+
+  explicit MP4DemuxerBinding(const char* aFileName = "dash_dashinit.mp4")
+    : resource(new MockMediaResource(aFileName))
+    , mDemuxer(new MP4Demuxer(resource))
+    , mTaskQueue(new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK)))
+    , mIndex(0)
+  {
+    EXPECT_EQ(NS_OK, resource->Open(nullptr));
+  }
+
+  template<typename Function>
+  void RunTestAndWait(const Function& aFunction)
+  {
+    Function func(aFunction);
+    RefPtr<MP4DemuxerBinding> binding = this;
+    mDemuxer->Init()->Then(mTaskQueue, __func__, Move(func), DO_FAIL);
+    mTaskQueue->AwaitShutdownAndIdle();
+  }
+
+  RefPtr<GenericPromise>
+  CheckTrackKeyFrame(MediaTrackDemuxer* aTrackDemuxer)
+  {
+    MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
+
+    RefPtr<MediaTrackDemuxer> track = aTrackDemuxer;
+    RefPtr<MP4DemuxerBinding> binding = this;
+
+    int64_t time = -1;
+    while (mIndex < mSamples.Length()) {
+      uint32_t i = mIndex++;
+      if (mSamples[i]->mKeyframe) {
+        time = mSamples[i]->mTime;
+        break;
+      }
+    }
+
+    RefPtr<GenericPromise> p = mCheckTrackKeyFramePromise.Ensure(__func__);
+
+    if (time == -1) {
+      mCheckTrackKeyFramePromise.Resolve(true, __func__);
+      return p;
+    }
+
+
+    DispatchTask(
+      [track, time, binding] () {
+        track->Seek(media::TimeUnit::FromMicroseconds(time))->Then(binding->mTaskQueue, __func__,
+          [track, time, binding] () {
+            track->GetSamples()->Then(binding->mTaskQueue, __func__,
+              [track, time, binding] (RefPtr<MediaTrackDemuxer::SamplesHolder> aSamples) {
+                EXPECT_EQ(time, aSamples->mSamples[0]->mTime);
+                binding->CheckTrackKeyFrame(track);
+              },
+              DO_FAIL
+            );
+          },
+          DO_FAIL
+        );
+      }
+    );
+
+    return p;
+  }
+
+  RefPtr<GenericPromise>
+  CheckTrackSamples(MediaTrackDemuxer* aTrackDemuxer)
+  {
+    MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
+
+    RefPtr<MediaTrackDemuxer> track = aTrackDemuxer;
+    RefPtr<MP4DemuxerBinding> binding = this;
+
+    RefPtr<GenericPromise> p = mCheckTrackSamples.Ensure(__func__);
+
+    DispatchTask(
+      [track, binding] () {
+        track->GetSamples()->Then(binding->mTaskQueue, __func__,
+          [track, binding] (RefPtr<MediaTrackDemuxer::SamplesHolder> aSamples) {
+            if (aSamples->mSamples.Length()) {
+              binding->mSamples.AppendElements(aSamples->mSamples);
+              binding->CheckTrackSamples(track);
+            }
+          },
+          [binding] (const MediaResult& aError) {
+            if (aError == NS_ERROR_DOM_MEDIA_END_OF_STREAM) {
+              EXPECT_TRUE(binding->mSamples.Length() > 1);
+              for (uint32_t i = 0; i < (binding->mSamples.Length() - 1); i++) {
+                EXPECT_LT(binding->mSamples[i]->mTimecode, binding->mSamples[i + 1]->mTimecode);
+                if (binding->mSamples[i]->mKeyframe) {
+                  binding->mKeyFrameTimecodes.AppendElement(binding->mSamples[i]->mTimecode);
+                }
+              }
+              binding->mCheckTrackSamples.Resolve(true, __func__);
+            } else {
+              EXPECT_TRUE(false);
+              binding->mCheckTrackSamples.Reject(aError, __func__);
+            }
+          }
+        );
+      }
+    );
+
+    return p;
+  }
+
+private:
+
+  template<typename FunctionType>
+  void
+  DispatchTask(FunctionType aFun)
+  {
+    RefPtr<Runnable> r = NS_NewRunnableFunction(aFun);
+    mTaskQueue->Dispatch(r.forget());
+  }
+
+  virtual ~MP4DemuxerBinding()
+  {
+  }
+};
+
+TEST(MP4Demuxer, Seek)
+{
+  RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding();
+
+  binding->RunTestAndWait([binding] () {
+    binding->mVideoTrack = binding->mDemuxer->GetTrackDemuxer(TrackInfo::kVideoTrack, 0);
+    binding->CheckTrackSamples(binding->mVideoTrack)
+      ->Then(binding->mTaskQueue, __func__,
+        [binding] () {
+          binding->CheckTrackKeyFrame(binding->mVideoTrack)
+            ->Then(binding->mTaskQueue, __func__,
+              [binding] () {
+                binding->mTaskQueue->BeginShutdown();
+              }, DO_FAIL);
+        }, DO_FAIL);
+  });
+}
+
+static nsCString
+ToCryptoString(const CryptoSample& aCrypto)
+{
+  nsCString res;
+  if (aCrypto.mValid) {
+    res.AppendPrintf("%d %d ", aCrypto.mMode, aCrypto.mIVSize);
+    for (size_t i = 0; i < aCrypto.mKeyId.Length(); i++) {
+      res.AppendPrintf("%02x", aCrypto.mKeyId[i]);
+    }
+    res.Append(" ");
+    for (size_t i = 0; i < aCrypto.mIV.Length(); i++) {
+      res.AppendPrintf("%02x", aCrypto.mIV[i]);
+    }
+    EXPECT_EQ(aCrypto.mPlainSizes.Length(), aCrypto.mEncryptedSizes.Length());
+    for (size_t i = 0; i < aCrypto.mPlainSizes.Length(); i++) {
+      res.AppendPrintf(" %d,%d", aCrypto.mPlainSizes[i],
+                       aCrypto.mEncryptedSizes[i]);
+    }
+  } else {
+    res.Append("no crypto");
+  }
+  return res;
+}
+
+#ifndef XP_WIN // VC2013 doesn't support C++11 array initialization.
+
+TEST(MP4Demuxer, CENCFragVideo)
+{
+  const char* video[] = {
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000000 5,684 5,16980",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000450 5,1826",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000004c3 5,1215",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000050f 5,1302",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000561 5,939",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000059c 5,763",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000005cc 5,672",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000005f6 5,748",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000625 5,1025",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000666 5,730",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000694 5,897",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000006cd 5,643",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000006f6 5,556",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000719 5,527",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000073a 5,606",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000760 5,701",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000078c 5,531",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000007ae 5,562",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000007d2 5,576",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000007f6 5,514",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000817 5,404",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000831 5,635",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000859 5,433",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000875 5,478",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000893 5,474",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000008b1 5,462",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000008ce 5,473",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000008ec 5,437",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000908 5,418",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000923 5,475",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000941 5,23133",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000ee7 5,475",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f05 5,402",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f1f 5,415",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f39 5,408",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f53 5,442",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f6f 5,385",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f88 5,368",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f9f 5,354",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000fb6 5,400",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000fcf 5,399",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000fe8 5,1098",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000102d 5,1508",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000108c 5,1345",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000010e1 5,1945",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000115b 5,1824",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000011cd 5,2133",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001253 5,2486",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000012ef 5,1739",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000135c 5,1836",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000013cf 5,2367",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001463 5,2571",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001504 5,3008",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000015c0 5,3255",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000168c 5,3225",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001756 5,3118",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001819 5,2407",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000018b0 5,2400",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001946 5,2158",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000019cd 5,2392",
+  };
+
+  RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding("gizmo-frag.mp4");
+
+  binding->RunTestAndWait([binding, video] () {
+    // grab all video samples.
+    binding->mVideoTrack = binding->mDemuxer->GetTrackDemuxer(TrackInfo::kVideoTrack, 0);
+    binding->CheckTrackSamples(binding->mVideoTrack)
+      ->Then(binding->mTaskQueue, __func__,
+        [binding, video] () {
+          for (uint32_t i = 0; i < binding->mSamples.Length(); i++) {
+            nsCString text = ToCryptoString(binding->mSamples[i]->mCrypto);
+            EXPECT_STREQ(video[i++], text.get());
+          }
+          EXPECT_EQ(ArrayLength(video), binding->mSamples.Length());
+          binding->mTaskQueue->BeginShutdown();
+        }, DO_FAIL);
+  });
+}
+
+TEST(MP4Demuxer, CENCFragAudio)
+{
+  const char* audio[] = {
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000000 0,281",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000012 0,257",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000023 0,246",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000033 0,257",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000044 0,260",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000055 0,260",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000066 0,272",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000077 0,280",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000089 0,284",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000009b 0,290",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000ae 0,278",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000c0 0,268",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000d1 0,307",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000e5 0,290",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000f8 0,304",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000010b 0,316",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000011f 0,308",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000133 0,301",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000146 0,318",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000015a 0,311",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000016e 0,303",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000181 0,325",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000196 0,334",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001ab 0,344",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001c1 0,344",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001d7 0,387",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001f0 0,396",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000209 0,368",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000220 0,373",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000238 0,425",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000253 0,428",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000026e 0,426",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000289 0,427",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002a4 0,424",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002bf 0,447",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002db 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002f7 0,442",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000313 0,444",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000032f 0,374",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000347 0,405",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000361 0,372",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000379 0,395",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000392 0,435",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003ae 0,426",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003c9 0,430",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003e4 0,390",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003fd 0,335",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000412 0,339",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000428 0,352",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000043e 0,364",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000455 0,398",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000046e 0,451",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000048b 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004a7 0,436",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004c3 0,424",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004de 0,428",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004f9 0,413",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000513 0,430",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000052e 0,450",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000054b 0,386",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000564 0,320",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000578 0,347",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000058e 0,382",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005a6 0,437",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005c2 0,387",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005db 0,340",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005f1 0,337",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000607 0,389",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000620 0,428",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000063b 0,426",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000656 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000672 0,456",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000068f 0,468",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000006ad 0,468",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000006cb 0,463",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000006e8 0,467",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000706 0,460",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000723 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000073f 0,453",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000075c 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000778 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000794 0,439",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000007b0 0,436",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000007cc 0,441",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000007e8 0,465",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000806 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000822 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000083e 0,469",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000085c 0,431",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000877 0,437",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000893 0,474",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000008b1 0,436",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000008cd 0,433",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000008e9 0,481",
+  };
+
+  RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding("gizmo-frag.mp4");
+
+  binding->RunTestAndWait([binding, audio] () {
+    // grab all audio samples.
+    binding->mAudioTrack = binding->mDemuxer->GetTrackDemuxer(TrackInfo::kAudioTrack, 0);
+    binding->CheckTrackSamples(binding->mAudioTrack)
+      ->Then(binding->mTaskQueue, __func__,
+        [binding, audio] () {
+          EXPECT_TRUE(binding->mSamples.Length() > 1);
+          for (uint32_t i = 0; i < binding->mSamples.Length(); i++) {
+            nsCString text = ToCryptoString(binding->mSamples[i]->mCrypto);
+            EXPECT_STREQ(audio[i++], text.get());
+          }
+          EXPECT_EQ(ArrayLength(audio), binding->mSamples.Length());
+          binding->mTaskQueue->BeginShutdown();
+        }, DO_FAIL);
+  });
+}
+
+#endif
+
+TEST(MP4Demuxer, GetNextKeyframe)
+{
+  RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding("gizmo-frag.mp4");
+
+  binding->RunTestAndWait([binding] () {
+    // Insert a [0,end] buffered range, to simulate Moof's being buffered
+    // via MSE.
+    auto len = binding->resource->GetLength();
+    binding->resource->MockAddBufferedRange(0, len);
+
+    // gizmp-frag has two keyframes; one at dts=cts=0, and another at
+    // dts=cts=1000000. Verify we get expected results.
+    media::TimeUnit time;
+    binding->mVideoTrack = binding->mDemuxer->GetTrackDemuxer(TrackInfo::kVideoTrack, 0);
+    binding->mVideoTrack->Reset();
+    binding->mVideoTrack->GetNextRandomAccessPoint(&time);
+    EXPECT_EQ(time.ToMicroseconds(), 0);
+    binding->mVideoTrack->GetSamples()->Then(binding->mTaskQueue, __func__,
+      [binding] () {
+        media::TimeUnit time;
+        binding->mVideoTrack->GetNextRandomAccessPoint(&time);
+        EXPECT_EQ(time.ToMicroseconds(), 1000000);
+        binding->mTaskQueue->BeginShutdown();
+      },
+      DO_FAIL
+    );
+  });
+}
+
+TEST(MP4Demuxer, ZeroInLastMoov)
+{
+  RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding("short-zero-in-moov.mp4");
+  binding->RunTestAndWait([binding] () {
+    // It demuxes without error. That is sufficient.
+    binding->mTaskQueue->BeginShutdown();
+  });
+}
+
+
+TEST(MP4Demuxer, ZeroInMoovQuickTime)
+{
+  RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding("short-zero-inband.mov");
+  binding->RunTestAndWait([binding] () {
+    // It demuxes without error. That is sufficient.
+    binding->mTaskQueue->BeginShutdown();
+  });
+}
+
+TEST(MP4Demuxer, IgnoreMinus1Duration)
+{
+  RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding("negative_duration.mp4");
+  binding->RunTestAndWait([binding] () {
+    // It demuxes without error. That is sufficient.
+    binding->mTaskQueue->BeginShutdown();
+  });
+}
+
+#undef DO_FAIL
diff --git a/dom/media/gtest/TestMP4Reader.cpp b/dom/media/gtest/TestMP4Reader.cpp
new file mode 100644
index 000000000..f08f7a40d
--- /dev/null
+++ b/dom/media/gtest/TestMP4Reader.cpp
@@ -0,0 +1,217 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "MP4Reader.h"
+#include "MP4Decoder.h"
+#include "mozilla/SharedThreadPool.h"
+#include "MockMediaResource.h"
+#include "MockMediaDecoderOwner.h"
+#include "mozilla/Preferences.h"
+#include "TimeUnits.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+class TestBinding
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(TestBinding);
+
+  RefPtr<MP4Decoder> decoder;
+  RefPtr<MockMediaResource> resource;
+  RefPtr<MP4Reader> reader;
+
+  explicit TestBinding(const char* aFileName = "gizmo.mp4")
+    : decoder(new MP4Decoder())
+    , resource(new MockMediaResource(aFileName))
+    , reader(new MP4Reader(decoder))
+  {
+    EXPECT_EQ(NS_OK, Preferences::SetBool(
+                       "media.use-blank-decoder", true));
+
+    EXPECT_EQ(NS_OK, resource->Open(nullptr));
+    decoder->SetResource(resource);
+
+    reader->Init(nullptr);
+    // This needs to be done before invoking GetBuffered. This is normally
+    // done by MediaDecoderStateMachine.
+    reader->DispatchSetStartTime(0);
+  }
+
+  void Init() {
+    nsCOMPtr<nsIThread> thread;
+    nsCOMPtr<nsIRunnable> r = NewRunnableMethod(this, &TestBinding::ReadMetadata);
+    nsresult rv = NS_NewThread(getter_AddRefs(thread), r);
+    EXPECT_EQ(NS_OK, rv);
+    thread->Shutdown();
+  }
+
+private:
+  virtual ~TestBinding()
+  {
+    {
+      RefPtr<TaskQueue> queue = reader->OwnerThread();
+      nsCOMPtr<nsIRunnable> task = NewRunnableMethod(reader, &MP4Reader::Shutdown);
+      // Hackily bypass the tail dispatcher so that we can AwaitShutdownAndIdle.
+      // In production code we'd use BeginShutdown + promises.
+      queue->Dispatch(task.forget(), AbstractThread::AssertDispatchSuccess,
+                      AbstractThread::TailDispatch);
+      queue->AwaitShutdownAndIdle();
+    }
+    decoder = nullptr;
+    resource = nullptr;
+    reader = nullptr;
+    SharedThreadPool::SpinUntilEmpty();
+  }
+
+  void ReadMetadata()
+  {
+    MediaInfo info;
+    MetadataTags* tags;
+    EXPECT_EQ(NS_OK, reader->ReadMetadata(&info, &tags));
+  }
+};
+
+TEST(MP4Reader, BufferedRange)
+{
+  RefPtr<TestBinding> b = new TestBinding();
+  b->Init();
+
+  // Video 3-4 sec, audio 2.986666-4.010666 sec
+  b->resource->MockAddBufferedRange(248400, 327455);
+
+  media::TimeIntervals ranges = b->reader->GetBuffered();
+  EXPECT_EQ(1U, ranges.Length());
+  EXPECT_NEAR(270000 / 90000.0, ranges.Start(0).ToSeconds(), 0.000001);
+  EXPECT_NEAR(360000 / 90000.0, ranges.End(0).ToSeconds(), 0.000001);
+}
+
+TEST(MP4Reader, BufferedRangeMissingLastByte)
+{
+  RefPtr<TestBinding> b = new TestBinding();
+  b->Init();
+
+  // Dropping the last byte of the video
+  b->resource->MockClearBufferedRanges();
+  b->resource->MockAddBufferedRange(248400, 324912);
+  b->resource->MockAddBufferedRange(324913, 327455);
+
+  media::TimeIntervals ranges = b->reader->GetBuffered();
+  EXPECT_EQ(1U, ranges.Length());
+  EXPECT_NEAR(270000.0 / 90000.0, ranges.Start(0).ToSeconds(), 0.000001);
+  EXPECT_NEAR(357000 / 90000.0, ranges.End(0).ToSeconds(), 0.000001);
+}
+
+TEST(MP4Reader, BufferedRangeSyncFrame)
+{
+  RefPtr<TestBinding> b = new TestBinding();
+  b->Init();
+
+  // Check that missing the first byte at 2 seconds skips right through to 3
+  // seconds because of a missing sync frame
+  b->resource->MockClearBufferedRanges();
+  b->resource->MockAddBufferedRange(146336, 327455);
+
+  media::TimeIntervals ranges = b->reader->GetBuffered();
+  EXPECT_EQ(1U, ranges.Length());
+  EXPECT_NEAR(270000.0 / 90000.0, ranges.Start(0).ToSeconds(), 0.000001);
+  EXPECT_NEAR(360000 / 90000.0, ranges.End(0).ToSeconds(), 0.000001);
+}
+
+TEST(MP4Reader, CompositionOrder)
+{
+  RefPtr<TestBinding> b = new TestBinding("mediasource_test.mp4");
+  b->Init();
+
+  // The first 5 video samples of this file are:
+  // Video timescale=2500
+  // Frame Start  Size  Time  Duration  Sync
+  //     1    48  5455   166        83  Yes
+  //     2  5503   145   249        83
+  //     3  6228   575   581        83
+  //     4  7383   235   415        83
+  //     5  8779   183   332        83
+  //     6  9543   191   498        83
+  //
+  // Audio timescale=44100
+  //     1  5648   580     0      1024  Yes
+  //     2  6803   580  1024      1058  Yes
+  //     3  7618   581  2082      1014  Yes
+  //     4  8199   580  3096      1015  Yes
+  //     5  8962   581  4111      1014  Yes
+  //     6  9734   580  5125      1014  Yes
+  //     7 10314   581  6139      1059  Yes
+  //     8 11207   580  7198      1014  Yes
+  //     9 12035   581  8212      1014  Yes
+  //    10 12616   580  9226      1015  Yes
+  //    11 13220   581  10241     1014  Yes
+
+  b->resource->MockClearBufferedRanges();
+  // First two frames in decoding + first audio frame
+  b->resource->MockAddBufferedRange(48, 5503);   // Video 1
+  b->resource->MockAddBufferedRange(5503, 5648); // Video 2
+  b->resource->MockAddBufferedRange(6228, 6803); // Video 3
+
+  // Audio - 5 frames; 0 - 139206 us
+  b->resource->MockAddBufferedRange(5648, 6228);
+  b->resource->MockAddBufferedRange(6803, 7383);
+  b->resource->MockAddBufferedRange(7618, 8199);
+  b->resource->MockAddBufferedRange(8199, 8779);
+  b->resource->MockAddBufferedRange(8962, 9563);
+  b->resource->MockAddBufferedRange(9734, 10314);
+  b->resource->MockAddBufferedRange(10314, 10895);
+  b->resource->MockAddBufferedRange(11207, 11787);
+  b->resource->MockAddBufferedRange(12035, 12616);
+  b->resource->MockAddBufferedRange(12616, 13196);
+  b->resource->MockAddBufferedRange(13220, 13901);
+
+  media::TimeIntervals ranges = b->reader->GetBuffered();
+  EXPECT_EQ(2U, ranges.Length());
+
+  EXPECT_NEAR(166.0 / 2500.0, ranges.Start(0).ToSeconds(), 0.000001);
+  EXPECT_NEAR(332.0 / 2500.0, ranges.End(0).ToSeconds(), 0.000001);
+
+  EXPECT_NEAR(581.0 / 2500.0, ranges.Start(1).ToSeconds(), 0.000001);
+  EXPECT_NEAR(11255.0 / 44100.0, ranges.End(1).ToSeconds(), 0.000001);
+}
+
+TEST(MP4Reader, Normalised)
+{
+  RefPtr<TestBinding> b = new TestBinding("mediasource_test.mp4");
+  b->Init();
+
+  // The first 5 video samples of this file are:
+  // Video timescale=2500
+  // Frame Start  Size  Time  Duration  Sync
+  //     1    48  5455   166        83  Yes
+  //     2  5503   145   249        83
+  //     3  6228   575   581        83
+  //     4  7383   235   415        83
+  //     5  8779   183   332        83
+  //     6  9543   191   498        83
+  //
+  // Audio timescale=44100
+  //     1  5648   580     0      1024  Yes
+  //     2  6803   580  1024      1058  Yes
+  //     3  7618   581  2082      1014  Yes
+  //     4  8199   580  3096      1015  Yes
+  //     5  8962   581  4111      1014  Yes
+  //     6  9734   580  5125      1014  Yes
+  //     7 10314   581  6139      1059  Yes
+  //     8 11207   580  7198      1014  Yes
+  //     9 12035   581  8212      1014  Yes
+  //    10 12616   580  9226      1015  Yes
+  //    11 13220   581  10241     1014  Yes
+
+  b->resource->MockClearBufferedRanges();
+  b->resource->MockAddBufferedRange(48, 13901);
+
+  media::TimeIntervals ranges = b->reader->GetBuffered();
+  EXPECT_EQ(1U, ranges.Length());
+
+  EXPECT_NEAR(166.0 / 2500.0, ranges.Start(0).ToSeconds(), 0.000001);
+  EXPECT_NEAR(11255.0 / 44100.0, ranges.End(0).ToSeconds(), 0.000001);
+}
diff --git a/dom/media/gtest/TestMediaDataDecoder.cpp b/dom/media/gtest/TestMediaDataDecoder.cpp
new file mode 100644
index 000000000..47e78bf7e
--- /dev/null
+++ b/dom/media/gtest/TestMediaDataDecoder.cpp
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "Benchmark.h"
+#include "MockMediaResource.h"
+#include "DecoderTraits.h"
+#include "MP4Demuxer.h"
+#include "WebMDemuxer.h"
+
+using namespace mozilla;
+
+class BenchmarkRunner
+{
+public:
+  explicit BenchmarkRunner(Benchmark* aBenchmark)
+    : mBenchmark(aBenchmark) {}
+
+  uint32_t Run()
+  {
+    bool done = false;
+    uint32_t result = 0;
+
+    mBenchmark->Init();
+    mBenchmark->Run()->Then(
+      AbstractThread::MainThread(), __func__,
+      [&](uint32_t aDecodeFps) { result = aDecodeFps; done = true; },
+      [&]() { done = true; });
+
+    // Wait until benchmark completes.
+    while (!done) {
+      NS_ProcessNextEvent();
+    }
+    return result;
+  }
+
+private:
+  RefPtr<Benchmark> mBenchmark;
+};
+
+TEST(MediaDataDecoder, H264)
+{
+  if (!DecoderTraits::IsMP4TypeAndEnabled(NS_LITERAL_CSTRING("video/mp4")
+        , /* DecoderDoctorDiagnostics* */ nullptr)) {
+    EXPECT_TRUE(true);
+  } else {
+    RefPtr<MediaResource> resource =
+      new MockMediaResource("gizmo.mp4", NS_LITERAL_CSTRING("video/mp4"));
+    nsresult rv = resource->Open(nullptr);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+
+    BenchmarkRunner runner(new Benchmark(new MP4Demuxer(resource)));
+    EXPECT_GT(runner.Run(), 0u);
+  }
+}
+
+TEST(MediaDataDecoder, VP9)
+{
+  if (!DecoderTraits::IsWebMTypeAndEnabled(NS_LITERAL_CSTRING("video/webm"))) {
+    EXPECT_TRUE(true);
+  } else {
+    RefPtr<MediaResource> resource =
+      new MockMediaResource("vp9cake.webm", NS_LITERAL_CSTRING("video/webm"));
+    nsresult rv = resource->Open(nullptr);
+    EXPECT_TRUE(NS_SUCCEEDED(rv));
+
+    BenchmarkRunner runner(new Benchmark(new WebMDemuxer(resource)));
+    EXPECT_GT(runner.Run(), 0u);
+  }
+}
diff --git a/dom/media/gtest/TestMediaEventSource.cpp b/dom/media/gtest/TestMediaEventSource.cpp
new file mode 100644
index 000000000..75fb09f20
--- /dev/null
+++ b/dom/media/gtest/TestMediaEventSource.cpp
@@ -0,0 +1,337 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+
+#include "mozilla/TaskQueue.h"
+#include "mozilla/UniquePtr.h"
+#include "MediaEventSource.h"
+#include "VideoUtils.h"
+
+using namespace mozilla;
+
+/*
+ * Test if listeners receive the event data correctly.
+ */
+TEST(MediaEventSource, SingleListener)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<int> source;
+  int i = 0;
+
+  auto func = [&] (int j) { i += j; };
+  MediaEventListener listener = source.Connect(queue, func);
+
+  // Call Notify 3 times. The listener should be also called 3 times.
+  source.Notify(3);
+  source.Notify(5);
+  source.Notify(7);
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+
+  // Verify the event data is passed correctly to the listener.
+  EXPECT_EQ(i, 15); // 3 + 5 + 7
+  listener.Disconnect();
+}
+
+TEST(MediaEventSource, MultiListener)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<int> source;
+  int i = 0;
+  int j = 0;
+
+  auto func1 = [&] (int k) { i = k * 2; };
+  auto func2 = [&] (int k) { j = k * 3; };
+  MediaEventListener listener1 = source.Connect(queue, func1);
+  MediaEventListener listener2 = source.Connect(queue, func2);
+
+  // Both listeners should receive the event.
+  source.Notify(11);
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+
+  // Verify the event data is passed correctly to the listener.
+  EXPECT_EQ(i, 22); // 11 * 2
+  EXPECT_EQ(j, 33); // 11 * 3
+
+  listener1.Disconnect();
+  listener2.Disconnect();
+}
+
+/*
+ * Test if disconnecting a listener prevents events from coming.
+ */
+TEST(MediaEventSource, DisconnectAfterNotification)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<int> source;
+  int i = 0;
+
+  MediaEventListener listener;
+  auto func = [&] (int j) { i += j; listener.Disconnect(); };
+  listener = source.Connect(queue, func);
+
+  // Call Notify() twice. Since we disconnect the listener when receiving
+  // the 1st event, the 2nd event should not reach the listener.
+  source.Notify(11);
+  source.Notify(11);
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+
+  // Check only the 1st event is received.
+  EXPECT_EQ(i, 11);
+}
+
+TEST(MediaEventSource, DisconnectBeforeNotification)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<int> source;
+  int i = 0;
+  int j = 0;
+
+  auto func1 = [&] (int k) { i = k * 2; };
+  auto func2 = [&] (int k) { j = k * 3; };
+  MediaEventListener listener1 = source.Connect(queue, func1);
+  MediaEventListener listener2 = source.Connect(queue, func2);
+
+  // Disconnect listener2 before notification. Only listener1 should receive
+  // the event.
+  listener2.Disconnect();
+  source.Notify(11);
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+
+  EXPECT_EQ(i, 22); // 11 * 2
+  EXPECT_EQ(j, 0); // event not received
+
+  listener1.Disconnect();
+}
+
+/*
+ * Test we don't hit the assertion when calling Connect() and Disconnect()
+ * repeatedly.
+ */
+TEST(MediaEventSource, DisconnectAndConnect)
+{
+  RefPtr<TaskQueue> queue;
+  MediaEventProducerExc<int> source;
+  MediaEventListener listener = source.Connect(queue, [](){});
+  listener.Disconnect();
+  listener = source.Connect(queue, [](){});
+  listener.Disconnect();
+}
+
+/*
+ * Test void event type.
+ */
+TEST(MediaEventSource, VoidEventType)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<void> source;
+  int i = 0;
+
+  // Test function object.
+  auto func = [&] () { ++i; };
+  MediaEventListener listener1 = source.Connect(queue, func);
+
+  // Test member function.
+  struct Foo {
+    Foo() : j(1) {}
+    void OnNotify() {
+      j *= 2;
+    }
+    int j;
+  } foo;
+  MediaEventListener listener2 = source.Connect(queue, &foo, &Foo::OnNotify);
+
+  // Call Notify 2 times. The listener should be also called 2 times.
+  source.Notify();
+  source.Notify();
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+
+  // Verify the event data is passed correctly to the listener.
+  EXPECT_EQ(i, 2); // ++i called twice
+  EXPECT_EQ(foo.j, 4); // |j *= 2| called twice
+  listener1.Disconnect();
+  listener2.Disconnect();
+}
+
+/*
+ * Test listeners can take various event types (T, T&&, const T& and void).
+ */
+TEST(MediaEventSource, ListenerType1)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<int> source;
+  int i = 0;
+
+  // Test various argument types.
+  auto func1 = [&] (int&& j) { i += j; };
+  auto func2 = [&] (const int& j) { i += j; };
+  auto func3 = [&] () { i += 1; };
+  MediaEventListener listener1 = source.Connect(queue, func1);
+  MediaEventListener listener2 = source.Connect(queue, func2);
+  MediaEventListener listener3 = source.Connect(queue, func3);
+
+  source.Notify(1);
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+
+  EXPECT_EQ(i, 3);
+
+  listener1.Disconnect();
+  listener2.Disconnect();
+  listener3.Disconnect();
+}
+
+TEST(MediaEventSource, ListenerType2)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<int> source;
+
+  struct Foo {
+    Foo() : mInt(0) {}
+    void OnNotify1(int&& i) { mInt += i; }
+    void OnNotify2(const int& i) { mInt += i; }
+    void OnNotify3() { mInt += 1; }
+    void OnNotify4(int i) const { mInt += i; }
+    void OnNotify5(int i) volatile { mInt += i; }
+    mutable int mInt;
+  } foo;
+
+  // Test member functions which might be CV qualified.
+  MediaEventListener listener1 = source.Connect(queue, &foo, &Foo::OnNotify1);
+  MediaEventListener listener2 = source.Connect(queue, &foo, &Foo::OnNotify2);
+  MediaEventListener listener3 = source.Connect(queue, &foo, &Foo::OnNotify3);
+  MediaEventListener listener4 = source.Connect(queue, &foo, &Foo::OnNotify4);
+  MediaEventListener listener5 = source.Connect(queue, &foo, &Foo::OnNotify5);
+
+  source.Notify(1);
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+
+  EXPECT_EQ(foo.mInt, 5);
+
+  listener1.Disconnect();
+  listener2.Disconnect();
+  listener3.Disconnect();
+  listener4.Disconnect();
+  listener5.Disconnect();
+}
+
+struct SomeEvent {
+  explicit SomeEvent(int& aCount) : mCount(aCount) {}
+  // Increment mCount when copy constructor is called to know how many times
+  // the event data is copied.
+  SomeEvent(const SomeEvent& aOther) : mCount(aOther.mCount) {
+    ++mCount;
+  }
+  int& mCount;
+};
+
+/*
+ * Test we don't have unnecessary copies of the event data.
+ */
+TEST(MediaEventSource, CopyEvent1)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<SomeEvent> source;
+  int i = 0;
+
+  auto func = [] (SomeEvent&& aEvent) {};
+  struct Foo {
+    void OnNotify(SomeEvent&& aEvent) {}
+  } foo;
+
+  MediaEventListener listener1 = source.Connect(queue, func);
+  MediaEventListener listener2 = source.Connect(queue, &foo, &Foo::OnNotify);
+
+  // We expect i to be 2 since SomeEvent should be copied only once when
+  // passing to each listener.
+  source.Notify(SomeEvent(i));
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+  EXPECT_EQ(i, 2);
+  listener1.Disconnect();
+  listener2.Disconnect();
+}
+
+TEST(MediaEventSource, CopyEvent2)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducer<SomeEvent> source;
+  int i = 0;
+
+  auto func = [] () {};
+  struct Foo {
+    void OnNotify() {}
+  } foo;
+
+  MediaEventListener listener1 = source.Connect(queue, func);
+  MediaEventListener listener2 = source.Connect(queue, &foo, &Foo::OnNotify);
+
+  // SomeEvent won't be copied at all since the listeners take no arguments.
+  source.Notify(SomeEvent(i));
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+  EXPECT_EQ(i, 0);
+  listener1.Disconnect();
+  listener2.Disconnect();
+}
+
+/*
+ * Test move-only types.
+ */
+TEST(MediaEventSource, MoveOnly)
+{
+  RefPtr<TaskQueue> queue = new TaskQueue(
+    GetMediaThreadPool(MediaThreadType::PLAYBACK));
+
+  MediaEventProducerExc<UniquePtr<int>> source;
+
+  auto func = [] (UniquePtr<int>&& aEvent) {
+    EXPECT_EQ(*aEvent, 20);
+  };
+  MediaEventListener listener = source.Connect(queue, func);
+
+  // It is OK to pass an rvalue which is move-only.
+  source.Notify(UniquePtr<int>(new int(20)));
+  // It is an error to pass an lvalue which is move-only.
+  // UniquePtr<int> event(new int(30));
+  // source.Notify(event);
+
+  queue->BeginShutdown();
+  queue->AwaitShutdownAndIdle();
+  listener.Disconnect();
+}
diff --git a/dom/media/gtest/TestMediaFormatReader.cpp b/dom/media/gtest/TestMediaFormatReader.cpp
new file mode 100644
index 000000000..ad222e8b8
--- /dev/null
+++ b/dom/media/gtest/TestMediaFormatReader.cpp
@@ -0,0 +1,248 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "mozilla/dom/HTMLMediaElement.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/TaskQueue.h"
+#include "ImageContainer.h"
+#include "Layers.h"
+#include "MediaData.h"
+#include "MediaFormatReader.h"
+#include "MP4Decoder.h"
+#include "MockMediaDecoderOwner.h"
+#include "MockMediaResource.h"
+#include "VideoFrameContainer.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+class MockMP4Decoder : public MP4Decoder
+{
+public:
+  MockMP4Decoder()
+    : MP4Decoder(new MockMediaDecoderOwner())
+  {}
+
+  // Avoid the assertion.
+  AbstractCanonical<media::NullableTimeUnit>* CanonicalDurationOrNull() override
+  {
+    return nullptr;
+  }
+};
+
+class MediaFormatReaderBinding
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaFormatReaderBinding);
+  RefPtr<MockMP4Decoder> mDecoder;
+  RefPtr<MockMediaResource> mResource;
+  RefPtr<MediaDecoderReader> mReader;
+  RefPtr<TaskQueue> mTaskQueue;
+  explicit MediaFormatReaderBinding(const char* aFileName = "gizmo.mp4")
+    : mDecoder(new MockMP4Decoder())
+    , mResource(new MockMediaResource(aFileName))
+    , mReader(new MediaFormatReader(mDecoder,
+                                    new MP4Demuxer(mResource),
+                                    new VideoFrameContainer(
+                                      (HTMLMediaElement*)(0x1),
+                                      layers::LayerManager::CreateImageContainer(
+                                        layers::ImageContainer::ASYNCHRONOUS))
+                                    ))
+    , mTaskQueue(new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK)))
+  {
+  }
+
+  bool Init() {
+    // Init Resource.
+    nsresult rv = mResource->Open(nullptr);
+    if (NS_FAILED(rv)) {
+      return false;
+    }
+    mDecoder->SetResource(mResource);
+    // Init Reader.
+    rv = mReader->Init();
+    if (NS_FAILED(rv)) {
+      return false;
+    }
+    return true;
+  }
+
+  void OnMetadataReadAudio(MetadataHolder* aMetadata)
+  {
+    EXPECT_TRUE(aMetadata);
+    mReader->RequestAudioData()
+      ->Then(mReader->OwnerThread(), __func__, this,
+             &MediaFormatReaderBinding::OnAudioRawDataDemuxed,
+             &MediaFormatReaderBinding::OnNotDemuxed);
+  }
+
+  void OnMetadataReadVideo(MetadataHolder* aMetadata)
+  {
+    EXPECT_TRUE(aMetadata);
+    mReader->RequestVideoData(true, 0)
+      ->Then(mReader->OwnerThread(), __func__, this,
+             &MediaFormatReaderBinding::OnVideoRawDataDemuxed,
+             &MediaFormatReaderBinding::OnNotDemuxed);
+  }
+
+  void OnMetadataNotRead(const MediaResult& aError) {
+    EXPECT_TRUE(false);
+    ReaderShutdown();
+  }
+
+  void OnAudioRawDataDemuxed(MediaData* aAudioSample)
+  {
+    EXPECT_TRUE(aAudioSample);
+    EXPECT_EQ(MediaData::RAW_DATA, aAudioSample->mType);
+    ReaderShutdown();
+  }
+
+  void OnVideoRawDataDemuxed(MediaData* aVideoSample)
+  {
+    EXPECT_TRUE(aVideoSample);
+    EXPECT_EQ(MediaData::RAW_DATA, aVideoSample->mType);
+    ReaderShutdown();
+  }
+
+  void OnNotDemuxed(const MediaResult& aReason)
+  {
+    EXPECT_TRUE(false);
+    ReaderShutdown();
+  }
+
+  void ReaderShutdown()
+  {
+    RefPtr<MediaFormatReaderBinding> self = this;
+    mReader->Shutdown()
+      ->Then(mTaskQueue, __func__,
+             [self]() {
+               self->mTaskQueue->BeginShutdown();
+             },
+             [self]() {
+               EXPECT_TRUE(false);
+               self->mTaskQueue->BeginShutdown();
+             }); //Then
+  }
+  template<class Function>
+  void RunTestAndWait(Function&& aFunction)
+  {
+    RefPtr<Runnable> r = NS_NewRunnableFunction(Forward<Function>(aFunction));
+    mTaskQueue->Dispatch(r.forget());
+    mTaskQueue->AwaitShutdownAndIdle();
+  }
+private:
+  ~MediaFormatReaderBinding()
+  {
+    mDecoder->Shutdown();
+  }
+};
+
+
+template <typename T>
+T GetPref(const char* aPrefKey);
+
+template <>
+bool GetPref<bool>(const char* aPrefKey)
+{
+  return Preferences::GetBool(aPrefKey);
+}
+
+template <typename T>
+void SetPref(const char* a, T value);
+
+template <>
+void SetPref<bool>(const char* aPrefKey, bool aValue)
+{
+  Unused << Preferences::SetBool(aPrefKey, aValue);
+}
+
+template <typename T>
+class PreferencesRAII
+{
+public:
+  explicit PreferencesRAII(const char* aPrefKey, T aValue)
+  : mPrefKey(aPrefKey)
+  {
+    mDefaultPref = GetPref<T>(aPrefKey);
+    SetPref(aPrefKey, aValue);
+  }
+  ~PreferencesRAII()
+  {
+    SetPref(mPrefKey, mDefaultPref);
+  }
+private:
+  T mDefaultPref;
+  const char* mPrefKey;
+};
+
+TEST(MediaFormatReader, RequestAudioRawData)
+{
+  PreferencesRAII<bool> pref =
+    PreferencesRAII<bool>("media.use-blank-decoder",
+                          true);
+  RefPtr<MediaFormatReaderBinding> b = new MediaFormatReaderBinding();
+  if (!b->Init())
+  {
+    EXPECT_TRUE(false);
+    // Stop the test since initialization failed.
+    return;
+  }
+  if (!b->mReader->IsDemuxOnlySupported())
+  {
+    EXPECT_TRUE(false);
+    // Stop the test since the reader cannot support demuxed-only demand.
+    return;
+  }
+  // Switch to demuxed-only mode.
+  b->mReader->SetDemuxOnly(true);
+  // To ensure the MediaDecoderReader::InitializationTask and
+  // MediaDecoderReader::SetDemuxOnly can be done.
+  NS_ProcessNextEvent();
+  auto testCase = [b]() {
+    InvokeAsync(b->mReader->OwnerThread(),
+                b->mReader.get(),
+                __func__,
+                &MediaDecoderReader::AsyncReadMetadata)
+      ->Then(b->mReader->OwnerThread(), __func__, b.get(),
+             &MediaFormatReaderBinding::OnMetadataReadAudio,
+             &MediaFormatReaderBinding::OnMetadataNotRead);
+  };
+  b->RunTestAndWait(testCase);
+}
+TEST(MediaFormatReader, RequestVideoRawData)
+{
+  PreferencesRAII<bool> pref =
+    PreferencesRAII<bool>("media.use-blank-decoder",
+                          true);
+  RefPtr<MediaFormatReaderBinding> b = new MediaFormatReaderBinding();
+  if (!b->Init())
+  {
+    EXPECT_TRUE(false);
+    // Stop the test since initialization failed.
+    return;
+  }
+  if (!b->mReader->IsDemuxOnlySupported())
+  {
+    EXPECT_TRUE(false);
+    // Stop the test since the reader cannot support demuxed-only demand.
+    return;
+  }
+  // Switch to demuxed-only mode.
+  b->mReader->SetDemuxOnly(true);
+  // To ensure the MediaDecoderReader::InitializationTask and
+  // MediaDecoderReader::SetDemuxOnly can be done.
+  NS_ProcessNextEvent();
+  auto testCase = [b]() {
+    InvokeAsync(b->mReader->OwnerThread(),
+                b->mReader.get(),
+                __func__,
+                &MediaDecoderReader::AsyncReadMetadata)
+      ->Then(b->mReader->OwnerThread(), __func__, b.get(),
+             &MediaFormatReaderBinding::OnMetadataReadVideo,
+             &MediaFormatReaderBinding::OnMetadataNotRead);
+  };
+  b->RunTestAndWait(testCase);
+}
diff --git a/dom/media/gtest/TestMozPromise.cpp b/dom/media/gtest/TestMozPromise.cpp
new file mode 100644
index 000000000..b1d363bd5
--- /dev/null
+++ b/dom/media/gtest/TestMozPromise.cpp
@@ -0,0 +1,257 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+
+#include "mozilla/TaskQueue.h"
+#include "mozilla/MozPromise.h"
+
+#include "nsISupportsImpl.h"
+#include "mozilla/SharedThreadPool.h"
+#include "VideoUtils.h"
+
+using namespace mozilla;
+
+typedef MozPromise<int, double, false> TestPromise;
+typedef TestPromise::ResolveOrRejectValue RRValue;
+
+class MOZ_STACK_CLASS AutoTaskQueue
+{
+public:
+  AutoTaskQueue()
+    : mTaskQueue(new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK)))
+  {}
+
+  ~AutoTaskQueue()
+  {
+    mTaskQueue->AwaitShutdownAndIdle();
+  }
+
+  TaskQueue* Queue() { return mTaskQueue; }
+private:
+  RefPtr<TaskQueue> mTaskQueue;
+};
+
+class DelayedResolveOrReject : public Runnable
+{
+public:
+  DelayedResolveOrReject(TaskQueue* aTaskQueue,
+                         TestPromise::Private* aPromise,
+                         TestPromise::ResolveOrRejectValue aValue,
+                         int aIterations)
+  : mTaskQueue(aTaskQueue)
+  , mPromise(aPromise)
+  , mValue(aValue)
+  , mIterations(aIterations)
+  {}
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
+    if (!mPromise) {
+      // Canceled.
+      return NS_OK;
+    }
+
+    if (--mIterations == 0) {
+      mPromise->ResolveOrReject(mValue, __func__);
+    } else {
+      nsCOMPtr<nsIRunnable> r = this;
+      mTaskQueue->Dispatch(r.forget());
+    }
+
+    return NS_OK;
+  }
+
+  void Cancel() {
+    mPromise = nullptr;
+  }
+
+protected:
+  ~DelayedResolveOrReject() {}
+
+private:
+  RefPtr<TaskQueue> mTaskQueue;
+  RefPtr<TestPromise::Private> mPromise;
+  TestPromise::ResolveOrRejectValue mValue;
+  int mIterations;
+};
+
+template<typename FunctionType>
+void
+RunOnTaskQueue(TaskQueue* aQueue, FunctionType aFun)
+{
+  nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(aFun);
+  aQueue->Dispatch(r.forget());
+}
+
+// std::function can't come soon enough. :-(
+#define DO_FAIL []()->void { EXPECT_TRUE(false); }
+
+TEST(MozPromise, BasicResolve)
+{
+  AutoTaskQueue atq;
+  RefPtr<TaskQueue> queue = atq.Queue();
+  RunOnTaskQueue(queue, [queue] () -> void {
+    TestPromise::CreateAndResolve(42, __func__)->Then(queue, __func__,
+      [queue] (int aResolveValue) -> void { EXPECT_EQ(aResolveValue, 42); queue->BeginShutdown(); },
+      DO_FAIL);
+  });
+}
+
+TEST(MozPromise, BasicReject)
+{
+  AutoTaskQueue atq;
+  RefPtr<TaskQueue> queue = atq.Queue();
+  RunOnTaskQueue(queue, [queue] () -> void {
+    TestPromise::CreateAndReject(42.0, __func__)->Then(queue, __func__,
+      DO_FAIL,
+      [queue] (int aRejectValue) -> void { EXPECT_EQ(aRejectValue, 42.0); queue->BeginShutdown(); });
+  });
+}
+
+TEST(MozPromise, AsyncResolve)
+{
+  AutoTaskQueue atq;
+  RefPtr<TaskQueue> queue = atq.Queue();
+  RunOnTaskQueue(queue, [queue] () -> void {
+    RefPtr<TestPromise::Private> p = new TestPromise::Private(__func__);
+
+    // Kick off three racing tasks, and make sure we get the one that finishes earliest.
+    RefPtr<DelayedResolveOrReject> a = new DelayedResolveOrReject(queue, p, RRValue::MakeResolve(32), 10);
+    RefPtr<DelayedResolveOrReject> b = new DelayedResolveOrReject(queue, p, RRValue::MakeResolve(42), 5);
+    RefPtr<DelayedResolveOrReject> c = new DelayedResolveOrReject(queue, p, RRValue::MakeReject(32.0), 7);
+
+    nsCOMPtr<nsIRunnable> ref = a.get();
+    queue->Dispatch(ref.forget());
+    ref = b.get();
+    queue->Dispatch(ref.forget());
+    ref = c.get();
+    queue->Dispatch(ref.forget());
+
+    p->Then(queue, __func__, [queue, a, b, c] (int aResolveValue) -> void {
+      EXPECT_EQ(aResolveValue, 42);
+      a->Cancel();
+      b->Cancel();
+      c->Cancel();
+      queue->BeginShutdown();
+    }, DO_FAIL);
+  });
+}
+
+TEST(MozPromise, CompletionPromises)
+{
+  bool invokedPass = false;
+  AutoTaskQueue atq;
+  RefPtr<TaskQueue> queue = atq.Queue();
+  RunOnTaskQueue(queue, [queue, &invokedPass] () -> void {
+    TestPromise::CreateAndResolve(40, __func__)
+    ->Then(queue, __func__,
+      [] (int aVal) -> RefPtr<TestPromise> { return TestPromise::CreateAndResolve(aVal + 10, __func__); },
+      DO_FAIL)
+    ->CompletionPromise()
+    ->Then(queue, __func__, [&invokedPass] () -> void { invokedPass = true; }, DO_FAIL)
+    ->CompletionPromise()
+    ->Then(queue, __func__,
+      [queue] (int aVal) -> RefPtr<TestPromise> {
+        RefPtr<TestPromise::Private> p = new TestPromise::Private(__func__);
+        nsCOMPtr<nsIRunnable> resolver = new DelayedResolveOrReject(queue, p, RRValue::MakeResolve(aVal - 8), 10);
+        queue->Dispatch(resolver.forget());
+        return RefPtr<TestPromise>(p);
+      },
+      DO_FAIL)
+    ->CompletionPromise()
+    ->Then(queue, __func__,
+      [queue] (int aVal) -> RefPtr<TestPromise> { return TestPromise::CreateAndReject(double(aVal - 42) + 42.0, __func__); },
+      DO_FAIL)
+    ->CompletionPromise()
+    ->Then(queue, __func__,
+      DO_FAIL,
+      [queue, &invokedPass] (double aVal) -> void { EXPECT_EQ(aVal, 42.0); EXPECT_TRUE(invokedPass); queue->BeginShutdown(); });
+  });
+}
+
+TEST(MozPromise, PromiseAllResolve)
+{
+  AutoTaskQueue atq;
+  RefPtr<TaskQueue> queue = atq.Queue();
+  RunOnTaskQueue(queue, [queue] () -> void {
+
+    nsTArray<RefPtr<TestPromise>> promises;
+    promises.AppendElement(TestPromise::CreateAndResolve(22, __func__));
+    promises.AppendElement(TestPromise::CreateAndResolve(32, __func__));
+    promises.AppendElement(TestPromise::CreateAndResolve(42, __func__));
+
+    TestPromise::All(queue, promises)->Then(queue, __func__,
+      [queue] (const nsTArray<int>& aResolveValues) -> void {
+        EXPECT_EQ(aResolveValues.Length(), 3UL);
+        EXPECT_EQ(aResolveValues[0], 22);
+        EXPECT_EQ(aResolveValues[1], 32);
+        EXPECT_EQ(aResolveValues[2], 42);
+        queue->BeginShutdown();
+      },
+      DO_FAIL
+    );
+  });
+}
+
+TEST(MozPromise, PromiseAllReject)
+{
+  AutoTaskQueue atq;
+  RefPtr<TaskQueue> queue = atq.Queue();
+  RunOnTaskQueue(queue, [queue] () -> void {
+
+    nsTArray<RefPtr<TestPromise>> promises;
+    promises.AppendElement(TestPromise::CreateAndResolve(22, __func__));
+    promises.AppendElement(TestPromise::CreateAndReject(32.0, __func__));
+    promises.AppendElement(TestPromise::CreateAndResolve(42, __func__));
+   // Ensure that more than one rejection doesn't cause a crash (bug #1207312)
+    promises.AppendElement(TestPromise::CreateAndReject(52.0, __func__));
+
+    TestPromise::All(queue, promises)->Then(queue, __func__,
+      DO_FAIL,
+      [queue] (float aRejectValue) -> void {
+        EXPECT_EQ(aRejectValue, 32.0);
+        queue->BeginShutdown();
+      }
+    );
+  });
+}
+
+// Test we don't hit the assertions in MozPromise when exercising promise
+// chaining upon task queue shutdown.
+TEST(MozPromise, Chaining)
+{
+  AutoTaskQueue atq;
+  RefPtr<TaskQueue> queue = atq.Queue();
+  MozPromiseRequestHolder<TestPromise> holder;
+
+  RunOnTaskQueue(queue, [queue, &holder] () {
+    auto p = TestPromise::CreateAndResolve(42, __func__);
+    const size_t kIterations = 100;
+    for (size_t i = 0; i < kIterations; ++i) {
+      p = p->Then(queue, __func__,
+        [] (int aVal) {
+          EXPECT_EQ(aVal, 42);
+        },
+        [] () {}
+      )->CompletionPromise();
+
+      if (i == kIterations / 2) {
+        p->Then(queue, __func__,
+          [queue, &holder] () {
+            holder.Disconnect();
+            queue->BeginShutdown();
+          },
+          DO_FAIL);
+      }
+    }
+    // We will hit the assertion if we don't disconnect the leaf Request
+    // in the promise chain.
+    holder.Begin(p->Then(queue, __func__, [] () {}, [] () {}));
+  });
+}
+
+#undef DO_FAIL
diff --git a/dom/media/gtest/TestRust.cpp b/dom/media/gtest/TestRust.cpp
new file mode 100644
index 000000000..86d0e99b8
--- /dev/null
+++ b/dom/media/gtest/TestRust.cpp
@@ -0,0 +1,9 @@
+#include <stdint.h>
+#include "gtest/gtest.h"
+
+extern "C" uint8_t* test_rust();
+
+TEST(rust, CallFromCpp) {
+  auto greeting = test_rust();
+  EXPECT_STREQ(reinterpret_cast<char*>(greeting), "hello from rust.");
+}
diff --git a/dom/media/gtest/TestTimeUnit.cpp b/dom/media/gtest/TestTimeUnit.cpp
new file mode 100644
index 000000000..605e0e90c
--- /dev/null
+++ b/dom/media/gtest/TestTimeUnit.cpp
@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "TimeUnits.h"
+#include <algorithm>
+#include <vector>
+
+using namespace mozilla;
+
+TEST(TimeUnit, Rounding)
+{
+  int64_t usecs = 66261715;
+  double seconds = media::TimeUnit::FromMicroseconds(usecs).ToSeconds();
+  EXPECT_EQ(media::TimeUnit::FromSeconds(seconds).ToMicroseconds(), usecs);
+
+  seconds = 4.169470;
+  usecs = 4169470;
+  EXPECT_EQ(media::TimeUnit::FromSeconds(seconds).ToMicroseconds(), usecs);
+}
diff --git a/dom/media/gtest/TestTrackEncoder.cpp b/dom/media/gtest/TestTrackEncoder.cpp
new file mode 100644
index 000000000..01d5c86e9
--- /dev/null
+++ b/dom/media/gtest/TestTrackEncoder.cpp
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "OpusTrackEncoder.h"
+
+using namespace mozilla;
+
+class TestOpusTrackEncoder : public OpusTrackEncoder
+{
+public:
+  // Return true if it has successfully initialized the Opus encoder.
+  bool TestOpusCreation(int aChannels, int aSamplingRate)
+  {
+    if (Init(aChannels, aSamplingRate) == NS_OK) {
+      if (GetPacketDuration()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Return the sample rate of data to be fed to the Opus encoder, could be
+  // re-sampled if it was not one of the Opus supported sampling rates.
+  // Init() is expected to be called first.
+  int TestGetOutputSampleRate()
+  {
+    return mInitialized ? GetOutputSampleRate() : 0;
+  }
+};
+
+static bool
+TestOpusInit(int aChannels, int aSamplingRate)
+{
+  TestOpusTrackEncoder encoder;
+  return encoder.TestOpusCreation(aChannels, aSamplingRate);
+}
+
+static int
+TestOpusResampler(int aChannels, int aSamplingRate)
+{
+  TestOpusTrackEncoder encoder;
+  EXPECT_TRUE(encoder.TestOpusCreation(aChannels, aSamplingRate));
+  return encoder.TestGetOutputSampleRate();
+}
+
+TEST(Media, OpusEncoder_Init)
+{
+  // Expect false with 0 or negative channels of input signal.
+  EXPECT_FALSE(TestOpusInit(0, 16000));
+  EXPECT_FALSE(TestOpusInit(-1, 16000));
+
+  // The Opus format supports up to 8 channels, and supports multitrack audio up
+  // to 255 channels, but the current implementation supports only mono and
+  // stereo, and downmixes any more than that.
+  // Expect false with channels of input signal exceed the max supported number.
+  EXPECT_FALSE(TestOpusInit(8 + 1, 16000));
+
+  // Should accept channels within valid range.
+  for (int i = 1; i <= 8; i++) {
+    EXPECT_TRUE(TestOpusInit(i, 16000));
+  }
+
+  // Expect false with 0 or negative sampling rate of input signal.
+  EXPECT_FALSE(TestOpusInit(1, 0));
+  EXPECT_FALSE(TestOpusInit(1, -1));
+
+  // Verify sample rate bounds checking.
+  EXPECT_FALSE(TestOpusInit(2, 2000));
+  EXPECT_FALSE(TestOpusInit(2, 4000));
+  EXPECT_FALSE(TestOpusInit(2, 7999));
+  EXPECT_TRUE(TestOpusInit(2, 8000));
+  EXPECT_TRUE(TestOpusInit(2, 192000));
+  EXPECT_FALSE(TestOpusInit(2, 192001));
+  EXPECT_FALSE(TestOpusInit(2, 200000));
+}
+
+TEST(Media, OpusEncoder_Resample)
+{
+  // Sampling rates of data to be fed to Opus encoder, should remain unchanged
+  // if it is one of Opus supported rates (8000, 12000, 16000, 24000 and 48000
+  // (kHz)) at initialization.
+  EXPECT_TRUE(TestOpusResampler(1, 8000) == 8000);
+  EXPECT_TRUE(TestOpusResampler(1, 12000) == 12000);
+  EXPECT_TRUE(TestOpusResampler(1, 16000) == 16000);
+  EXPECT_TRUE(TestOpusResampler(1, 24000) == 24000);
+  EXPECT_TRUE(TestOpusResampler(1, 48000) == 48000);
+
+  // Otherwise, it should be resampled to 48kHz by resampler.
+  EXPECT_FALSE(TestOpusResampler(1, 9600) == 9600);
+  EXPECT_FALSE(TestOpusResampler(1, 44100) == 44100);
+}
diff --git a/dom/media/gtest/TestVPXDecoding.cpp b/dom/media/gtest/TestVPXDecoding.cpp
new file mode 100644
index 000000000..d14c4d24e
--- /dev/null
+++ b/dom/media/gtest/TestVPXDecoding.cpp
@@ -0,0 +1,103 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "mozilla/ArrayUtils.h"
+#include "nsTArray.h"
+#include "VPXDecoder.h"
+
+#include <stdio.h>
+
+using namespace mozilla;
+
+static void
+ReadVPXFile(const char* aPath, nsTArray<uint8_t>& aBuffer)
+{
+  FILE* f = fopen(aPath, "rb");
+  ASSERT_NE(f, (FILE *) nullptr);
+
+  int r = fseek(f, 0, SEEK_END);
+  ASSERT_EQ(r, 0);
+
+  long size = ftell(f);
+  ASSERT_NE(size, -1);
+  aBuffer.SetLength(size);
+
+  r = fseek(f, 0, SEEK_SET);
+  ASSERT_EQ(r, 0);
+
+  size_t got = fread(aBuffer.Elements(), 1, size, f);
+  ASSERT_EQ(got, size_t(size));
+
+  r = fclose(f);
+  ASSERT_EQ(r, 0);
+}
+
+static
+vpx_codec_iface_t*
+ParseIVFConfig(nsTArray<uint8_t>& data, vpx_codec_dec_cfg_t& config)
+{
+  if (data.Length() < 32 + 12) {
+    // Not enough data for file & first frame headers.
+    return nullptr;
+  }
+  if (data[0] != 'D' || data[1] != 'K' || data[2] != 'I' || data[3] != 'F') {
+    // Expect 'DKIP'
+    return nullptr;
+  }
+  if (data[4] != 0 || data[5] != 0) {
+    // Expect version==0.
+    return nullptr;
+  }
+  if (data[8] != 'V' || data[9] != 'P'
+      || (data[10] != '8' && data[10] != '9')
+      || data[11] != '0') {
+    // Expect 'VP80' or 'VP90'.
+    return nullptr;
+  }
+  config.w = uint32_t(data[12]) || (uint32_t(data[13]) << 8);
+  config.h = uint32_t(data[14]) || (uint32_t(data[15]) << 8);
+  vpx_codec_iface_t* codec = (data[10] == '8')
+                             ? vpx_codec_vp8_dx()
+                             : vpx_codec_vp9_dx();
+  // Remove headers, to just leave raw VPx data to be decoded.
+  data.RemoveElementsAt(0, 32 + 12);
+  return codec;
+}
+
+struct TestFileData {
+  const char* mFilename;
+  vpx_codec_err_t mDecodeResult;
+};
+static const TestFileData testFiles[] = {
+  { "test_case_1224361.vp8.ivf", VPX_CODEC_OK },
+  { "test_case_1224363.vp8.ivf", VPX_CODEC_CORRUPT_FRAME },
+  { "test_case_1224369.vp8.ivf", VPX_CODEC_CORRUPT_FRAME }
+};
+
+TEST(libvpx, test_cases)
+{
+  for (size_t test = 0; test < ArrayLength(testFiles); ++test) {
+    nsTArray<uint8_t> data;
+    ReadVPXFile(testFiles[test].mFilename, data);
+    ASSERT_GT(data.Length(), 0u);
+
+    vpx_codec_dec_cfg_t config;
+    vpx_codec_iface_t* dx = ParseIVFConfig(data, config);
+    ASSERT_TRUE(dx);
+    config.threads = 2;
+
+    vpx_codec_ctx_t ctx;
+    PodZero(&ctx);
+    vpx_codec_err_t r = vpx_codec_dec_init(&ctx, dx, &config, 0);
+    ASSERT_EQ(VPX_CODEC_OK, r);
+
+    r = vpx_codec_decode(&ctx, data.Elements(), data.Length(), nullptr, 0);
+    // This test case is known to be corrupt.
+    EXPECT_EQ(testFiles[test].mDecodeResult, r);
+
+    r = vpx_codec_destroy(&ctx);
+    EXPECT_EQ(VPX_CODEC_OK, r);
+  }
+}
diff --git a/dom/media/gtest/TestVideoSegment.cpp b/dom/media/gtest/TestVideoSegment.cpp
new file mode 100644
index 000000000..f7d5aed21
--- /dev/null
+++ b/dom/media/gtest/TestVideoSegment.cpp
@@ -0,0 +1,51 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "VideoSegment.h"
+
+using namespace mozilla;
+
+namespace mozilla {
+  namespace layer {
+    class Image;
+  } // namespace layer
+} // namespace mozilla
+
+TEST(VideoSegment, TestAppendFrameForceBlack)
+{
+  RefPtr<layers::Image> testImage = nullptr;
+
+  VideoSegment segment;
+  segment.AppendFrame(testImage.forget(),
+                      mozilla::StreamTime(90000),
+                      mozilla::gfx::IntSize(640, 480),
+                      PRINCIPAL_HANDLE_NONE,
+                      true);
+
+  VideoSegment::ChunkIterator iter(segment);
+  while (!iter.IsEnded()) {
+    VideoChunk chunk = *iter;
+    EXPECT_TRUE(chunk.mFrame.GetForceBlack());
+    iter.Next();
+  }
+}
+
+TEST(VideoSegment, TestAppendFrameNotForceBlack)
+{
+  RefPtr<layers::Image> testImage = nullptr;
+
+  VideoSegment segment;
+  segment.AppendFrame(testImage.forget(),
+                      mozilla::StreamTime(90000),
+                      mozilla::gfx::IntSize(640, 480),
+                      PRINCIPAL_HANDLE_NONE);
+
+  VideoSegment::ChunkIterator iter(segment);
+  while (!iter.IsEnded()) {
+    VideoChunk chunk = *iter;
+    EXPECT_FALSE(chunk.mFrame.GetForceBlack());
+    iter.Next();
+  }
+}
diff --git a/dom/media/gtest/TestVideoTrackEncoder.cpp b/dom/media/gtest/TestVideoTrackEncoder.cpp
new file mode 100644
index 000000000..65826c9b4
--- /dev/null
+++ b/dom/media/gtest/TestVideoTrackEncoder.cpp
@@ -0,0 +1,351 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include <algorithm>
+
+#include "mozilla/ArrayUtils.h"
+#include "VP8TrackEncoder.h"
+#include "ImageContainer.h"
+#include "MediaStreamGraph.h"
+#include "MediaStreamListener.h"
+#include "WebMWriter.h" // TODO: it's weird to include muxer header to get the class definition of VP8 METADATA
+
+using ::testing::TestWithParam;
+using ::testing::Values;
+
+using namespace mozilla::layers;
+using namespace mozilla;
+
+// A helper object to generate of different YUV planes.
+class YUVBufferGenerator {
+public:
+  YUVBufferGenerator() {}
+
+  void Init(const mozilla::gfx::IntSize &aSize)
+  {
+    mImageSize = aSize;
+
+    int yPlaneLen = aSize.width * aSize.height;
+    int cbcrPlaneLen = (yPlaneLen + 1) / 2;
+    int frameLen = yPlaneLen + cbcrPlaneLen;
+
+    // Generate source buffer.
+    mSourceBuffer.SetLength(frameLen);
+
+    // Fill Y plane.
+    memset(mSourceBuffer.Elements(), 0x10, yPlaneLen);
+
+    // Fill Cb/Cr planes.
+    memset(mSourceBuffer.Elements() + yPlaneLen, 0x80, cbcrPlaneLen);
+  }
+
+  mozilla::gfx::IntSize GetSize() const
+  {
+    return mImageSize;
+  }
+
+  void Generate(nsTArray<RefPtr<Image> > &aImages)
+  {
+    aImages.AppendElement(CreateI420Image());
+    aImages.AppendElement(CreateNV12Image());
+    aImages.AppendElement(CreateNV21Image());
+  }
+
+private:
+  Image *CreateI420Image()
+  {
+    PlanarYCbCrImage *image = new RecyclingPlanarYCbCrImage(new BufferRecycleBin());
+    PlanarYCbCrData data;
+    data.mPicSize = mImageSize;
+
+    const uint32_t yPlaneSize = mImageSize.width * mImageSize.height;
+    const uint32_t halfWidth = (mImageSize.width + 1) / 2;
+    const uint32_t halfHeight = (mImageSize.height + 1) / 2;
+    const uint32_t uvPlaneSize = halfWidth * halfHeight;
+
+    // Y plane.
+    uint8_t *y = mSourceBuffer.Elements();
+    data.mYChannel = y;
+    data.mYSize.width = mImageSize.width;
+    data.mYSize.height = mImageSize.height;
+    data.mYStride = mImageSize.width;
+    data.mYSkip = 0;
+
+    // Cr plane.
+    uint8_t *cr = y + yPlaneSize + uvPlaneSize;
+    data.mCrChannel = cr;
+    data.mCrSkip = 0;
+
+    // Cb plane
+    uint8_t *cb = y + yPlaneSize;
+    data.mCbChannel = cb;
+    data.mCbSkip = 0;
+
+    // CrCb plane vectors.
+    data.mCbCrStride = halfWidth;
+    data.mCbCrSize.width = halfWidth;
+    data.mCbCrSize.height = halfHeight;
+
+    image->CopyData(data);
+    return image;
+  }
+
+  Image *CreateNV12Image()
+  {
+    PlanarYCbCrImage *image = new RecyclingPlanarYCbCrImage(new BufferRecycleBin());
+    PlanarYCbCrData data;
+    data.mPicSize = mImageSize;
+
+    const uint32_t yPlaneSize = mImageSize.width * mImageSize.height;
+    const uint32_t halfWidth = (mImageSize.width + 1) / 2;
+    const uint32_t halfHeight = (mImageSize.height + 1) / 2;
+
+    // Y plane.
+    uint8_t *y = mSourceBuffer.Elements();
+    data.mYChannel = y;
+    data.mYSize.width = mImageSize.width;
+    data.mYSize.height = mImageSize.height;
+    data.mYStride = mImageSize.width;
+    data.mYSkip = 0;
+
+    // Cr plane.
+    uint8_t *cr = y + yPlaneSize;
+    data.mCrChannel = cr;
+    data.mCrSkip = 1;
+
+    // Cb plane
+    uint8_t *cb = y + yPlaneSize + 1;
+    data.mCbChannel = cb;
+    data.mCbSkip = 1;
+
+    // 4:2:0.
+    data.mCbCrStride = mImageSize.width;
+    data.mCbCrSize.width = halfWidth;
+    data.mCbCrSize.height = halfHeight;
+
+    image->CopyData(data);
+    return image;
+  }
+
+  Image *CreateNV21Image()
+  {
+    PlanarYCbCrImage *image = new RecyclingPlanarYCbCrImage(new BufferRecycleBin());
+    PlanarYCbCrData data;
+    data.mPicSize = mImageSize;
+
+    const uint32_t yPlaneSize = mImageSize.width * mImageSize.height;
+    const uint32_t halfWidth = (mImageSize.width + 1) / 2;
+    const uint32_t halfHeight = (mImageSize.height + 1) / 2;
+
+    // Y plane.
+    uint8_t *y = mSourceBuffer.Elements();
+    data.mYChannel = y;
+    data.mYSize.width = mImageSize.width;
+    data.mYSize.height = mImageSize.height;
+    data.mYStride = mImageSize.width;
+    data.mYSkip = 0;
+
+    // Cr plane.
+    uint8_t *cr = y + yPlaneSize + 1;
+    data.mCrChannel = cr;
+    data.mCrSkip = 1;
+
+    // Cb plane
+    uint8_t *cb = y + yPlaneSize;
+    data.mCbChannel = cb;
+    data.mCbSkip = 1;
+
+    // 4:2:0.
+    data.mCbCrStride = mImageSize.width;
+    data.mCbCrSize.width = halfWidth;
+    data.mCbCrSize.height = halfHeight;
+
+    image->CopyData(data);
+    return image;
+  }
+
+private:
+  mozilla::gfx::IntSize mImageSize;
+  nsTArray<uint8_t> mSourceBuffer;
+};
+
+struct InitParam {
+  bool mShouldSucceed;  // This parameter should cause success or fail result
+  int  mWidth;          // frame width
+  int  mHeight;         // frame height
+};
+
+class TestVP8TrackEncoder: public VP8TrackEncoder
+{
+public:
+  explicit TestVP8TrackEncoder(TrackRate aTrackRate = 90000)
+    : VP8TrackEncoder(aTrackRate) {}
+
+  ::testing::AssertionResult TestInit(const InitParam &aParam)
+  {
+    nsresult result = Init(aParam.mWidth, aParam.mHeight, aParam.mWidth, aParam.mHeight);
+
+    if (((NS_FAILED(result) && aParam.mShouldSucceed)) || (NS_SUCCEEDED(result) && !aParam.mShouldSucceed))
+    {
+      return ::testing::AssertionFailure()
+                << " width = " << aParam.mWidth
+                << " height = " << aParam.mHeight;
+    }
+    else
+    {
+      return ::testing::AssertionSuccess();
+    }
+  }
+};
+
+// Init test
+TEST(VP8VideoTrackEncoder, Initialization)
+{
+  InitParam params[] = {
+    // Failure cases.
+    { false, 0, 0},      // Height/ width should be larger than 1.
+    { false, 0, 1},      // Height/ width should be larger than 1.
+    { false, 1, 0},       // Height/ width should be larger than 1.
+
+    // Success cases
+    { true, 640, 480},    // Standard VGA
+    { true, 800, 480},    // Standard WVGA
+    { true, 960, 540},    // Standard qHD
+    { true, 1280, 720}    // Standard HD
+  };
+
+  for (size_t i = 0; i < ArrayLength(params); i++)
+  {
+    TestVP8TrackEncoder encoder;
+    EXPECT_TRUE(encoder.TestInit(params[i]));
+  }
+}
+
+// Get MetaData test
+TEST(VP8VideoTrackEncoder, FetchMetaData)
+{
+  InitParam params[] = {
+    // Success cases
+    { true, 640, 480},    // Standard VGA
+    { true, 800, 480},    // Standard WVGA
+    { true, 960, 540},    // Standard qHD
+    { true, 1280, 720}    // Standard HD
+  };
+
+  for (size_t i = 0; i < ArrayLength(params); i++)
+  {
+    TestVP8TrackEncoder encoder;
+    EXPECT_TRUE(encoder.TestInit(params[i]));
+
+    RefPtr<TrackMetadataBase> meta = encoder.GetMetadata();
+    RefPtr<VP8Metadata> vp8Meta(static_cast<VP8Metadata*>(meta.get()));
+
+    // METADATA should be depend on how to initiate encoder.
+    EXPECT_TRUE(vp8Meta->mWidth == params[i].mWidth);
+    EXPECT_TRUE(vp8Meta->mHeight == params[i].mHeight);
+  }
+}
+
+// Encode test
+TEST(VP8VideoTrackEncoder, FrameEncode)
+{
+  // Initiate VP8 encoder
+  TestVP8TrackEncoder encoder;
+  InitParam param = {true, 640, 480};
+  encoder.TestInit(param);
+
+  // Create YUV images as source.
+  nsTArray<RefPtr<Image>> images;
+  YUVBufferGenerator generator;
+  generator.Init(mozilla::gfx::IntSize(640, 480));
+  generator.Generate(images);
+
+  // Put generated YUV frame into video segment.
+  // Duration of each frame is 1 second.
+  VideoSegment segment;
+  for (nsTArray<RefPtr<Image>>::size_type i = 0; i < images.Length(); i++)
+  {
+    RefPtr<Image> image = images[i];
+    segment.AppendFrame(image.forget(),
+                        mozilla::StreamTime(90000),
+                        generator.GetSize(),
+                        PRINCIPAL_HANDLE_NONE);
+  }
+
+  // track change notification.
+  encoder.SetCurrentFrames(segment);
+
+  // Pull Encoded Data back from encoder.
+  EncodedFrameContainer container;
+  EXPECT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
+}
+
+// Test encoding a track that has to skip frames.
+TEST(VP8VideoTrackEncoder, SkippedFrames)
+{
+  // Initiate VP8 encoder
+  TestVP8TrackEncoder encoder;
+  InitParam param = {true, 640, 480};
+  encoder.TestInit(param);
+  nsTArray<RefPtr<Image>> images;
+  YUVBufferGenerator generator;
+  generator.Init(mozilla::gfx::IntSize(640, 480));
+  TimeStamp now = TimeStamp::Now();
+  VideoSegment segment;
+
+  while (images.Length() < 100) { 
+    generator.Generate(images);
+  }
+
+  // Pass 100 frames of the shortest possible duration where we don't get
+  // rounding errors between input/output rate.
+  for (uint32_t i = 0; i < 100; ++i) {
+    segment.AppendFrame(images[i].forget(),
+                        mozilla::StreamTime(90), // 1ms
+                        generator.GetSize(),
+                        PRINCIPAL_HANDLE_NONE,
+                        false,
+                        now + TimeDuration::FromMilliseconds(i));
+  }
+
+  encoder.SetCurrentFrames(segment);
+
+  // End the track.
+  segment.Clear();
+  encoder.NotifyQueuedTrackChanges(nullptr, 0, 0, TrackEventCommand::TRACK_EVENT_ENDED, segment);
+
+  EncodedFrameContainer container;
+  ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
+
+  EXPECT_TRUE(encoder.IsEncodingComplete());
+
+  // Verify total duration being 100 * 1ms = 100ms in terms of 30fps frame
+  // durations (3 * 1/30s).
+  uint64_t totalDuration = 0;
+  for (auto& frame : container.GetEncodedFrames()) {
+    totalDuration += frame->GetDuration();
+  }
+  const uint64_t threeFrames = (PR_USEC_PER_SEC / 30) * 3;
+  EXPECT_EQ(threeFrames, totalDuration);
+}
+
+// EOS test
+TEST(VP8VideoTrackEncoder, EncodeComplete)
+{
+  // Initiate VP8 encoder
+  TestVP8TrackEncoder encoder;
+  InitParam param = {true, 640, 480};
+  encoder.TestInit(param);
+
+  // track end notification.
+  VideoSegment segment;
+  encoder.NotifyQueuedTrackChanges(nullptr, 0, 0, TrackEventCommand::TRACK_EVENT_ENDED, segment);
+
+  // Pull Encoded Data back from encoder. Since we have sent
+  // EOS to encoder, encoder.GetEncodedTrack should return
+  // NS_OK immidiately.
+  EncodedFrameContainer container;
+  EXPECT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
+}
diff --git a/dom/media/gtest/TestVideoUtils.cpp b/dom/media/gtest/TestVideoUtils.cpp
new file mode 100644
index 000000000..f803cbb1d
--- /dev/null
+++ b/dom/media/gtest/TestVideoUtils.cpp
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "nsString.h"
+#include "VideoUtils.h"
+
+using namespace mozilla;
+
+TEST(StringListRange, MakeStringListRange)
+{
+  static const struct
+  {
+    const char* mList;
+    const char* mExpected;
+  } tests[] =
+  {
+    { "", "" },
+    { " ", "" },
+    { ",", "" },
+    { " , ", "" },
+    { "a", "a|" },
+    { "  a  ", "a|" },
+    { "aa,bb", "aa|bb|" },
+    { " a a ,  b b  ", "a a|b b|" },
+    { " , ,a 1,,  ,b  2,", "a 1|b  2|" }
+  };
+
+  for (const auto& test : tests) {
+    nsCString list(test.mList);
+    nsCString out;
+    for (const auto& item : MakeStringListRange(list)) {
+      out += item;
+      out += "|";
+    }
+    EXPECT_STREQ(test.mExpected, out.Data());
+  }
+}
+
+TEST(StringListRange, StringListContains)
+{
+  static const struct
+  {
+    const char* mList;
+    const char* mItemToSearch;
+    bool mExpected;
+  } tests[] =
+  {
+    { "", "", false },
+    { "", "a", false },
+    { " ", "a", false },
+    { ",", "a", false },
+    { " , ", "", false },
+    { " , ", "a", false },
+    { "a", "a", true },
+    { "a", "b", false },
+    { "  a  ", "a", true },
+    { "aa,bb", "aa", true },
+    { "aa,bb", "bb", true },
+    { "aa,bb", "cc", false },
+    { "aa,bb", " aa ", false },
+    { " a a ,  b b  ", "a a", true },
+    { " , ,a 1,,  ,b  2,", "a 1", true },
+    { " , ,a 1,,  ,b  2,", "b  2", true },
+    { " , ,a 1,,  ,b  2,", "", false },
+    { " , ,a 1,,  ,b  2,", " ", false },
+    { " , ,a 1,,  ,b  2,", "A 1", false },
+    { " , ,A 1,,  ,b  2,", "a 1", false }
+  };
+
+  for (const auto& test : tests) {
+    nsCString list(test.mList);
+    nsCString itemToSearch(test.mItemToSearch);
+    EXPECT_EQ(test.mExpected, StringListContains(list, itemToSearch))
+      << "trying to find \"" << itemToSearch.Data()
+      << "\" in \"" << list.Data() << "\"";
+  }
+}
diff --git a/dom/media/gtest/TestWebMBuffered.cpp b/dom/media/gtest/TestWebMBuffered.cpp
new file mode 100644
index 000000000..4572c5767
--- /dev/null
+++ b/dom/media/gtest/TestWebMBuffered.cpp
@@ -0,0 +1,119 @@
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "mozilla/ArrayUtils.h"
+#include <stdio.h>
+#include "nsTArray.h"
+#include "WebMBufferedParser.h"
+
+using namespace mozilla;
+
+// "test.webm" contains 8 SimpleBlocks in a single Cluster.  The blocks with
+// timecodes 100000000 and are 133000000 skipped by WebMBufferedParser
+// because they occur after a block with timecode 160000000 and the parser
+// expects in-order timecodes per the WebM spec.  The remaining 6
+// SimpleBlocks have the following attributes:
+static const uint64_t gTimecodes[] = { 66000000, 160000000, 166000000, 200000000, 233000000, 320000000 };
+static const int64_t gEndOffsets[] = { 501, 772, 1244, 1380, 1543, 2015 };
+
+TEST(WebMBuffered, BasicTests)
+{
+  ReentrantMonitor dummy("dummy");
+  WebMBufferedParser parser(0);
+
+  nsTArray<WebMTimeDataOffset> mapping;
+  parser.Append(nullptr, 0, mapping, dummy);
+  EXPECT_TRUE(mapping.IsEmpty());
+  EXPECT_EQ(parser.mStartOffset, 0);
+  EXPECT_EQ(parser.mCurrentOffset, 0);
+
+  unsigned char buf[] = { 0x1a, 0x45, 0xdf, 0xa3 };
+  parser.Append(buf, ArrayLength(buf), mapping, dummy);
+  EXPECT_TRUE(mapping.IsEmpty());
+  EXPECT_EQ(parser.mStartOffset, 0);
+  EXPECT_EQ(parser.mCurrentOffset, 4);
+}
+
+static void
+ReadFile(const char* aPath, nsTArray<uint8_t>& aBuffer)
+{
+  FILE* f = fopen(aPath, "rb");
+  ASSERT_NE(f, (FILE *) nullptr);
+
+  int r = fseek(f, 0, SEEK_END);
+  ASSERT_EQ(r, 0);
+
+  long size = ftell(f);
+  ASSERT_NE(size, -1);
+  aBuffer.SetLength(size);
+
+  r = fseek(f, 0, SEEK_SET);
+  ASSERT_EQ(r, 0);
+
+  size_t got = fread(aBuffer.Elements(), 1, size, f);
+  ASSERT_EQ(got, size_t(size));
+
+  r = fclose(f);
+  ASSERT_EQ(r, 0);
+}
+
+TEST(WebMBuffered, RealData)
+{
+  ReentrantMonitor dummy("dummy");
+  WebMBufferedParser parser(0);
+
+  nsTArray<uint8_t> webmData;
+  ReadFile("test.webm", webmData);
+
+  nsTArray<WebMTimeDataOffset> mapping;
+  parser.Append(webmData.Elements(), webmData.Length(), mapping, dummy);
+  EXPECT_EQ(mapping.Length(), 6u);
+  EXPECT_EQ(parser.mStartOffset, 0);
+  EXPECT_EQ(parser.mCurrentOffset, int64_t(webmData.Length()));
+  EXPECT_EQ(parser.GetTimecodeScale(), 500000u);
+
+  for (uint32_t i = 0; i < mapping.Length(); ++i) {
+    EXPECT_EQ(mapping[i].mEndOffset, gEndOffsets[i]);
+    EXPECT_EQ(mapping[i].mSyncOffset, 361);
+    EXPECT_EQ(mapping[i].mTimecode, gTimecodes[i]);
+  }
+}
+
+TEST(WebMBuffered, RealDataAppend)
+{
+  ReentrantMonitor dummy("dummy");
+  WebMBufferedParser parser(0);
+  nsTArray<WebMTimeDataOffset> mapping;
+
+  nsTArray<uint8_t> webmData;
+  ReadFile("test.webm", webmData);
+
+  uint32_t arrayEntries = mapping.Length();
+  size_t offset = 0;
+  while (offset < webmData.Length()) {
+    parser.Append(webmData.Elements() + offset, 1, mapping, dummy);
+    offset += 1;
+    EXPECT_EQ(parser.mCurrentOffset, int64_t(offset));
+    if (mapping.Length() != arrayEntries) {
+      arrayEntries = mapping.Length();
+      ASSERT_LE(arrayEntries, 6u);
+      uint32_t i = arrayEntries - 1;
+      EXPECT_EQ(mapping[i].mEndOffset, gEndOffsets[i]);
+      EXPECT_EQ(mapping[i].mSyncOffset, 361);
+      EXPECT_EQ(mapping[i].mTimecode, gTimecodes[i]);
+      EXPECT_EQ(parser.GetTimecodeScale(), 500000u);
+    }
+  }
+  EXPECT_EQ(mapping.Length(), 6u);
+  EXPECT_EQ(parser.mStartOffset, 0);
+  EXPECT_EQ(parser.mCurrentOffset, int64_t(webmData.Length()));
+  EXPECT_EQ(parser.GetTimecodeScale(), 500000u);
+
+  for (uint32_t i = 0; i < mapping.Length(); ++i) {
+    EXPECT_EQ(mapping[i].mEndOffset, gEndOffsets[i]);
+    EXPECT_EQ(mapping[i].mSyncOffset, 361);
+    EXPECT_EQ(mapping[i].mTimecode, gTimecodes[i]);
+  }
+}
diff --git a/dom/media/gtest/TestWebMWriter.cpp b/dom/media/gtest/TestWebMWriter.cpp
new file mode 100644
index 000000000..e5fd8c771
--- /dev/null
+++ b/dom/media/gtest/TestWebMWriter.cpp
@@ -0,0 +1,376 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "gtest/gtest.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/MathAlgorithms.h"
+#include "nestegg/nestegg.h"
+#include "OpusTrackEncoder.h"
+#include "VP8TrackEncoder.h"
+#include "WebMWriter.h"
+
+using namespace mozilla;
+
+class WebMOpusTrackEncoder : public OpusTrackEncoder
+{
+public:
+  bool TestOpusCreation(int aChannels, int aSamplingRate)
+  {
+    if (NS_SUCCEEDED(Init(aChannels, aSamplingRate))) {
+      return true;
+    }
+    return false;
+  }
+};
+
+class WebMVP8TrackEncoder: public VP8TrackEncoder
+{
+public:
+  explicit WebMVP8TrackEncoder(TrackRate aTrackRate = 90000)
+    : VP8TrackEncoder(aTrackRate) {}
+
+  bool TestVP8Creation(int32_t aWidth, int32_t aHeight, int32_t aDisplayWidth,
+                       int32_t aDisplayHeight)
+  {
+    if (NS_SUCCEEDED(Init(aWidth, aHeight, aDisplayWidth, aDisplayHeight))) {
+      return true;
+    }
+    return false;
+  }
+};
+
+const uint64_t FIXED_DURATION = 1000000;
+const uint32_t FIXED_FRAMESIZE = 500;
+
+class TestWebMWriter: public WebMWriter
+{
+public:
+  explicit TestWebMWriter(int aTrackTypes)
+  : WebMWriter(aTrackTypes),
+    mTimestamp(0)
+  {}
+
+  void SetOpusMetadata(int aChannels, int aSampleRate) {
+    WebMOpusTrackEncoder opusEncoder;
+    EXPECT_TRUE(opusEncoder.TestOpusCreation(aChannels, aSampleRate));
+    RefPtr<TrackMetadataBase> opusMeta = opusEncoder.GetMetadata();
+    SetMetadata(opusMeta);
+  }
+  void SetVP8Metadata(int32_t aWidth, int32_t aHeight, int32_t aDisplayWidth,
+                      int32_t aDisplayHeight,TrackRate aTrackRate) {
+    WebMVP8TrackEncoder vp8Encoder;
+    EXPECT_TRUE(vp8Encoder.TestVP8Creation(aWidth, aHeight, aDisplayWidth,
+                                           aDisplayHeight));
+    RefPtr<TrackMetadataBase> vp8Meta = vp8Encoder.GetMetadata();
+    SetMetadata(vp8Meta);
+  }
+
+  // When we append an I-Frame into WebM muxer, the muxer will treat previous
+  // data as "a cluster".
+  // In these test cases, we will call the function many times to enclose the
+  // previous cluster so that we can retrieve data by |GetContainerData|.
+  void AppendDummyFrame(EncodedFrame::FrameType aFrameType,
+                        uint64_t aDuration) {
+    EncodedFrameContainer encodedVideoData;
+    nsTArray<uint8_t> frameData;
+    RefPtr<EncodedFrame> videoData = new EncodedFrame();
+    // Create dummy frame data.
+    frameData.SetLength(FIXED_FRAMESIZE);
+    videoData->SetFrameType(aFrameType);
+    videoData->SetTimeStamp(mTimestamp);
+    videoData->SetDuration(aDuration);
+    videoData->SwapInFrameData(frameData);
+    encodedVideoData.AppendEncodedFrame(videoData);
+    WriteEncodedTrack(encodedVideoData, 0);
+    mTimestamp += aDuration;
+  }
+
+  bool HaveValidCluster() {
+    nsTArray<nsTArray<uint8_t> > encodedBuf;
+    GetContainerData(&encodedBuf, 0);
+    return (encodedBuf.Length() > 0) ? true : false;
+  }
+
+  // Timestamp accumulator that increased by AppendDummyFrame.
+  // Keep it public that we can do some testcases about it.
+  uint64_t mTimestamp;
+};
+
+TEST(WebMWriter, Metadata)
+{
+  TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
+                        ContainerWriter::CREATE_VIDEO_TRACK);
+
+  // The output should be empty since we didn't set any metadata in writer.
+  nsTArray<nsTArray<uint8_t> > encodedBuf;
+  writer.GetContainerData(&encodedBuf, ContainerWriter::GET_HEADER);
+  EXPECT_TRUE(encodedBuf.Length() == 0);
+  writer.GetContainerData(&encodedBuf, ContainerWriter::FLUSH_NEEDED);
+  EXPECT_TRUE(encodedBuf.Length() == 0);
+
+  // Set opus metadata.
+  int channel = 1;
+  int sampleRate = 44100;
+  writer.SetOpusMetadata(channel, sampleRate);
+
+  // No output data since we didn't set both audio/video
+  // metadata in writer.
+  writer.GetContainerData(&encodedBuf, ContainerWriter::GET_HEADER);
+  EXPECT_TRUE(encodedBuf.Length() == 0);
+  writer.GetContainerData(&encodedBuf, ContainerWriter::FLUSH_NEEDED);
+  EXPECT_TRUE(encodedBuf.Length() == 0);
+
+  // Set vp8 metadata
+  int32_t width = 640;
+  int32_t height = 480;
+  int32_t displayWidth = 640;
+  int32_t displayHeight = 480;
+  TrackRate aTrackRate = 90000;
+  writer.SetVP8Metadata(width, height, displayWidth,
+                        displayHeight, aTrackRate);
+
+  writer.GetContainerData(&encodedBuf, ContainerWriter::GET_HEADER);
+  EXPECT_TRUE(encodedBuf.Length() > 0);
+}
+
+TEST(WebMWriter, Cluster)
+{
+  TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
+                        ContainerWriter::CREATE_VIDEO_TRACK);
+  // Set opus metadata.
+  int channel = 1;
+  int sampleRate = 48000;
+  writer.SetOpusMetadata(channel, sampleRate);
+  // Set vp8 metadata
+  int32_t width = 320;
+  int32_t height = 240;
+  int32_t displayWidth = 320;
+  int32_t displayHeight = 240;
+  TrackRate aTrackRate = 90000;
+  writer.SetVP8Metadata(width, height, displayWidth,
+                        displayHeight, aTrackRate);
+
+  nsTArray<nsTArray<uint8_t> > encodedBuf;
+  writer.GetContainerData(&encodedBuf, ContainerWriter::GET_HEADER);
+  EXPECT_TRUE(encodedBuf.Length() > 0);
+  encodedBuf.Clear();
+
+  // write the first I-Frame.
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+  // No data because the cluster is not closed.
+  EXPECT_FALSE(writer.HaveValidCluster());
+
+  // The second I-Frame.
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+  // Should have data because the first cluster is closed.
+  EXPECT_TRUE(writer.HaveValidCluster());
+
+  // P-Frame.
+  writer.AppendDummyFrame(EncodedFrame::VP8_P_FRAME, FIXED_DURATION);
+  // No data because the cluster is not closed.
+  EXPECT_FALSE(writer.HaveValidCluster());
+
+  // The third I-Frame.
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+  // Should have data because the second cluster is closed.
+  EXPECT_TRUE(writer.HaveValidCluster());
+}
+
+TEST(WebMWriter, FLUSH_NEEDED)
+{
+  TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
+                        ContainerWriter::CREATE_VIDEO_TRACK);
+  // Set opus metadata.
+  int channel = 2;
+  int sampleRate = 44100;
+  writer.SetOpusMetadata(channel, sampleRate);
+  // Set vp8 metadata
+  int32_t width = 176;
+  int32_t height = 352;
+  int32_t displayWidth = 176;
+  int32_t displayHeight = 352;
+  TrackRate aTrackRate = 100000;
+  writer.SetVP8Metadata(width, height, displayWidth,
+                        displayHeight, aTrackRate);
+
+  // write the first I-Frame.
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+
+  // P-Frame
+  writer.AppendDummyFrame(EncodedFrame::VP8_P_FRAME, FIXED_DURATION);
+  // Have data because the metadata is finished.
+  EXPECT_TRUE(writer.HaveValidCluster());
+  // No data because the cluster is not closed and the metatdata had been
+  // retrieved
+  EXPECT_FALSE(writer.HaveValidCluster());
+
+  nsTArray<nsTArray<uint8_t> > encodedBuf;
+  // Have data because the flag ContainerWriter::FLUSH_NEEDED
+  writer.GetContainerData(&encodedBuf, ContainerWriter::FLUSH_NEEDED);
+  EXPECT_TRUE(encodedBuf.Length() > 0);
+  encodedBuf.Clear();
+
+  // P-Frame
+  writer.AppendDummyFrame(EncodedFrame::VP8_P_FRAME, FIXED_DURATION);
+  // No data because there is no cluster right now. The I-Frame had been
+  // flushed out.
+  EXPECT_FALSE(writer.HaveValidCluster());
+
+  // I-Frame
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+  // No data because a cluster must starts form I-Frame and the
+  // cluster is not closed.
+  EXPECT_FALSE(writer.HaveValidCluster());
+
+  // I-Frame
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+  // Have data because the previous cluster is closed.
+  EXPECT_TRUE(writer.HaveValidCluster());
+}
+
+struct WebMioData {
+  nsTArray<uint8_t> data;
+  CheckedInt<size_t> offset;
+};
+
+static int webm_read(void* aBuffer, size_t aLength, void* aUserData)
+{
+  NS_ASSERTION(aUserData, "aUserData must point to a valid WebMioData");
+  WebMioData* ioData = static_cast<WebMioData*>(aUserData);
+
+  // Check the read length.
+  if (aLength > ioData->data.Length()) {
+    return 0;
+  }
+
+  // Check eos.
+  if (ioData->offset.value() >= ioData->data.Length()) {
+    return 0;
+  }
+
+  size_t oldOffset = ioData->offset.value();
+  ioData->offset += aLength;
+  if (!ioData->offset.isValid() ||
+      (ioData->offset.value() > ioData->data.Length())) {
+    return -1;
+  }
+  memcpy(aBuffer, ioData->data.Elements()+oldOffset, aLength);
+  return 1;
+}
+
+static int webm_seek(int64_t aOffset, int aWhence, void* aUserData)
+{
+  NS_ASSERTION(aUserData, "aUserData must point to a valid WebMioData");
+  WebMioData* ioData = static_cast<WebMioData*>(aUserData);
+
+  if (Abs(aOffset) > ioData->data.Length()) {
+    NS_ERROR("Invalid aOffset");
+    return -1;
+  }
+
+  switch (aWhence) {
+    case NESTEGG_SEEK_END:
+    {
+      CheckedInt<size_t> tempOffset = ioData->data.Length();
+      ioData->offset = tempOffset + aOffset;
+      break;
+    }
+    case NESTEGG_SEEK_CUR:
+      ioData->offset += aOffset;
+      break;
+    case NESTEGG_SEEK_SET:
+      ioData->offset = aOffset;
+      break;
+    default:
+      NS_ERROR("Unknown whence");
+      return -1;
+  }
+
+  if (!ioData->offset.isValid()) {
+    NS_ERROR("Invalid offset");
+    return -1;
+  }
+
+  return 0;
+}
+
+static int64_t webm_tell(void* aUserData)
+{
+  NS_ASSERTION(aUserData, "aUserData must point to a valid WebMioData");
+  WebMioData* ioData = static_cast<WebMioData*>(aUserData);
+  return ioData->offset.isValid() ? ioData->offset.value() : -1;
+}
+
+TEST(WebMWriter, bug970774_aspect_ratio)
+{
+  TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
+                        ContainerWriter::CREATE_VIDEO_TRACK);
+  // Set opus metadata.
+  int channel = 1;
+  int sampleRate = 44100;
+  writer.SetOpusMetadata(channel, sampleRate);
+  // Set vp8 metadata
+  int32_t width = 640;
+  int32_t height = 480;
+  int32_t displayWidth = 1280;
+  int32_t displayHeight = 960;
+  TrackRate aTrackRate = 90000;
+  writer.SetVP8Metadata(width, height, displayWidth,
+                        displayHeight, aTrackRate);
+
+  // write the first I-Frame.
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+
+  // write the second I-Frame.
+  writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
+
+  // Get the metadata and the first cluster.
+  nsTArray<nsTArray<uint8_t> > encodedBuf;
+  writer.GetContainerData(&encodedBuf, 0);
+  // Flatten the encodedBuf.
+  WebMioData ioData;
+  ioData.offset = 0;
+  for(uint32_t i = 0 ; i < encodedBuf.Length(); ++i) {
+    ioData.data.AppendElements(encodedBuf[i]);
+  }
+
+  // Use nestegg to verify the information in metadata.
+  nestegg* context = nullptr;
+  nestegg_io io;
+  io.read = webm_read;
+  io.seek = webm_seek;
+  io.tell = webm_tell;
+  io.userdata = static_cast<void*>(&ioData);
+  int rv = nestegg_init(&context, io, nullptr, -1);
+  EXPECT_EQ(rv, 0);
+  unsigned int ntracks = 0;
+  rv = nestegg_track_count(context, &ntracks);
+  EXPECT_EQ(rv, 0);
+  EXPECT_EQ(ntracks, (unsigned int)2);
+  for (unsigned int track = 0; track < ntracks; ++track) {
+    int id = nestegg_track_codec_id(context, track);
+    EXPECT_NE(id, -1);
+    int type = nestegg_track_type(context, track);
+    if (type == NESTEGG_TRACK_VIDEO) {
+      nestegg_video_params params;
+      rv = nestegg_track_video_params(context, track, &params);
+      EXPECT_EQ(rv, 0);
+      EXPECT_EQ(width, static_cast<int32_t>(params.width));
+      EXPECT_EQ(height, static_cast<int32_t>(params.height));
+      EXPECT_EQ(displayWidth, static_cast<int32_t>(params.display_width));
+      EXPECT_EQ(displayHeight, static_cast<int32_t>(params.display_height));
+    } else if (type == NESTEGG_TRACK_AUDIO) {
+      nestegg_audio_params params;
+      rv = nestegg_track_audio_params(context, track, &params);
+      EXPECT_EQ(rv, 0);
+      EXPECT_EQ(channel, static_cast<int>(params.channels));
+      EXPECT_EQ(static_cast<double>(sampleRate), params.rate);
+    }
+  }
+  if (context) {
+    nestegg_destroy(context);
+  }
+}
+
diff --git a/dom/media/gtest/dash_dashinit.mp4 b/dom/media/gtest/dash_dashinit.mp4
new file mode 100644
index 000000000..d19068f36
--- /dev/null
+++ b/dom/media/gtest/dash_dashinit.mp4
diff --git a/dom/media/gtest/hello.rs b/dom/media/gtest/hello.rs
new file mode 100644
index 000000000..cd111882a
--- /dev/null
+++ b/dom/media/gtest/hello.rs
@@ -0,0 +1,6 @@
+#[no_mangle]
+pub extern fn test_rust() -> *const u8 {
+    // NB: rust &str aren't null terminated.
+    let greeting = "hello from rust.\0";
+    greeting.as_ptr()
+}
diff --git a/dom/media/gtest/id3v2header.mp3 b/dom/media/gtest/id3v2header.mp3
new file mode 100644
index 000000000..2f5585d02
--- /dev/null
+++ b/dom/media/gtest/id3v2header.mp3
diff --git a/dom/media/gtest/mediasource_test.mp4 b/dom/media/gtest/mediasource_test.mp4
new file mode 100644
index 000000000..63707a914
--- /dev/null
+++ b/dom/media/gtest/mediasource_test.mp4
diff --git a/dom/media/gtest/moz.build b/dom/media/gtest/moz.build
new file mode 100644
index 000000000..fc92d5ef3
--- /dev/null
+++ b/dom/media/gtest/moz.build
@@ -0,0 +1,80 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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/.
+
+UNIFIED_SOURCES += [
+    'MockMediaResource.cpp',
+    'TestAudioBuffers.cpp',
+    'TestAudioCompactor.cpp',
+    'TestAudioMixer.cpp',
+    'TestAudioPacketizer.cpp',
+    'TestAudioSegment.cpp',
+    'TestGMPCrossOrigin.cpp',
+    'TestGMPRemoveAndDelete.cpp',
+    'TestGMPUtils.cpp',
+    'TestIntervalSet.cpp',
+    'TestMediaDataDecoder.cpp',
+    'TestMediaEventSource.cpp',
+    'TestMediaFormatReader.cpp',
+    'TestMozPromise.cpp',
+    'TestMP3Demuxer.cpp',
+    'TestMP4Demuxer.cpp',
+    # 'TestMP4Reader.cpp', disabled so we can turn check tests back on (bug 1175752)
+    'TestTrackEncoder.cpp',
+    'TestVideoSegment.cpp',
+    'TestVideoUtils.cpp',
+    'TestVPXDecoding.cpp',
+    'TestWebMBuffered.cpp',
+]
+
+if CONFIG['MOZ_WEBM_ENCODER']:
+    UNIFIED_SOURCES += [
+        'TestVideoTrackEncoder.cpp',
+        'TestWebMWriter.cpp',
+    ]
+
+if CONFIG['MOZ_RUST']:
+    UNIFIED_SOURCES += ['TestRust.cpp',]
+
+
+TEST_HARNESS_FILES.gtest += [
+    '../test/gizmo-frag.mp4',
+    '../test/gizmo.mp4',
+    '../test/vp9cake.webm',
+    'dash_dashinit.mp4',
+    'id3v2header.mp3',
+    'mediasource_test.mp4',
+    'negative_duration.mp4',
+    'noise.mp3',
+    'noise_vbr.mp3',
+    'short-zero-in-moov.mp4',
+    'short-zero-inband.mov',
+    'small-shot-false-positive.mp3',
+    'small-shot.mp3',
+    'test.webm',
+    'test_case_1224361.vp8.ivf',
+    'test_case_1224363.vp8.ivf',
+    'test_case_1224369.vp8.ivf',
+]
+
+include('/ipc/chromium/chromium-config.mozbuild')
+
+LOCAL_INCLUDES += [
+    '/dom/media',
+    '/dom/media/encoder',
+    '/dom/media/fmp4',
+    '/dom/media/gmp',
+    '/security/certverifier',
+    '/security/pkix/include',
+]
+
+FINAL_LIBRARY = 'xul-gtest'
+
+if CONFIG['GNU_CXX']:
+    CXXFLAGS += ['-Wno-error=shadow']
+
+USE_LIBS += [
+   'rlz',
+]
diff --git a/dom/media/gtest/negative_duration.mp4 b/dom/media/gtest/negative_duration.mp4
new file mode 100644
index 000000000..de86bf497
--- /dev/null
+++ b/dom/media/gtest/negative_duration.mp4
diff --git a/dom/media/gtest/noise.mp3 b/dom/media/gtest/noise.mp3
new file mode 100644
index 000000000..e76b50350
--- /dev/null
+++ b/dom/media/gtest/noise.mp3
diff --git a/dom/media/gtest/noise_vbr.mp3 b/dom/media/gtest/noise_vbr.mp3
new file mode 100644
index 000000000..284ebe40b
--- /dev/null
+++ b/dom/media/gtest/noise_vbr.mp3
diff --git a/dom/media/gtest/short-zero-in-moov.mp4 b/dom/media/gtest/short-zero-in-moov.mp4
new file mode 100644
index 000000000..577318c8f
--- /dev/null
+++ b/dom/media/gtest/short-zero-in-moov.mp4
diff --git a/dom/media/gtest/short-zero-inband.mov b/dom/media/gtest/short-zero-inband.mov
new file mode 100644
index 000000000..9c1864286
--- /dev/null
+++ b/dom/media/gtest/short-zero-inband.mov
diff --git a/dom/media/gtest/small-shot-false-positive.mp3 b/dom/media/gtest/small-shot-false-positive.mp3
new file mode 100644
index 000000000..2f1e79405
--- /dev/null
+++ b/dom/media/gtest/small-shot-false-positive.mp3
diff --git a/dom/media/gtest/small-shot.mp3 b/dom/media/gtest/small-shot.mp3
new file mode 100644
index 000000000..f9397a510
--- /dev/null
+++ b/dom/media/gtest/small-shot.mp3
diff --git a/dom/media/gtest/test.webm b/dom/media/gtest/test.webm
new file mode 100644
index 000000000..487914c4a
--- /dev/null
+++ b/dom/media/gtest/test.webm
diff --git a/dom/media/gtest/test_case_1224361.vp8.ivf b/dom/media/gtest/test_case_1224361.vp8.ivf
new file mode 100644
index 000000000..e2fe942f0
--- /dev/null
+++ b/dom/media/gtest/test_case_1224361.vp8.ivf
diff --git a/dom/media/gtest/test_case_1224363.vp8.ivf b/dom/media/gtest/test_case_1224363.vp8.ivf
new file mode 100644
index 000000000..6d2e4e020
--- /dev/null
+++ b/dom/media/gtest/test_case_1224363.vp8.ivf
diff --git a/dom/media/gtest/test_case_1224369.vp8.ivf b/dom/media/gtest/test_case_1224369.vp8.ivf
new file mode 100644
index 000000000..2f8deb114
--- /dev/null
+++ b/dom/media/gtest/test_case_1224369.vp8.ivf