Bug 1187214. Part 2 - add test cases for MediaEventSource. r=kinetik.
authorJW Wang <jwwang@mozilla.com>
Wed, 05 Aug 2015 10:24:13 +0800
changeset 287917 8caf2b95b2752e55d785fab9ff82c581db9b94f9
parent 287916 c0a6f89391ee20c27523d228a765ff22ce2b28fd
child 287918 b8a39e65c778d7c6a6c213e46e5655207f51bded
push id5067
push userraliiev@mozilla.com
push dateMon, 21 Sep 2015 14:04:52 +0000
treeherdermozilla-beta@14221ffe5b2f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskinetik
bugs1187214
milestone42.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1187214. Part 2 - add test cases for MediaEventSource. r=kinetik.
dom/media/gtest/TestMediaEventSource.cpp
dom/media/gtest/moz.build
new file mode 100644
--- /dev/null
+++ b/dom/media/gtest/TestMediaEventSource.cpp
@@ -0,0 +1,296 @@
+/* -*- 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 "MediaEventSource.h"
+#include "VideoUtils.h"
+
+using namespace mozilla;
+
+/*
+ * Test if listeners receive the event data correctly.
+ */
+TEST(MediaEventSource, SingleListener)
+{
+  nsRefPtr<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)
+{
+  nsRefPtr<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)
+{
+  nsRefPtr<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)
+{
+  nsRefPtr<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 void event type.
+ */
+TEST(MediaEventSource, VoidEventType)
+{
+  nsRefPtr<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)
+{
+  nsRefPtr<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)
+{
+  nsRefPtr<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)
+{
+  nsRefPtr<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)
+{
+  nsRefPtr<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();
+}
--- a/dom/media/gtest/moz.build
+++ b/dom/media/gtest/moz.build
@@ -5,16 +5,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 UNIFIED_SOURCES += [
     'MockMediaResource.cpp',
     'TestAudioCompactor.cpp',
     'TestGMPCrossOrigin.cpp',
     'TestGMPRemoveAndDelete.cpp',
     'TestIntervalSet.cpp',
+    'TestMediaEventSource.cpp',
     'TestMozPromise.cpp',
     'TestMP3Demuxer.cpp',
     'TestMP4Demuxer.cpp',
     # 'TestMP4Reader.cpp', disabled so we can turn check tests back on (bug 1175752)
     'TestTrackEncoder.cpp',
     'TestVideoSegment.cpp',
     'TestWebMBuffered.cpp',
 ]