Add m-esr52 at 52.6.0

1 files changed, 298 insertions, 0 deletions

diff --git a/dom/media/CanvasCaptureMediaStream.cpp b/dom/media/CanvasCaptureMediaStream.cpp
new file mode 100644
index 000000000..f40f01e21
--- /dev/null
+++ b/dom/media/CanvasCaptureMediaStream.cpp
@@ -0,0 +1,298 @@
+/* -*- 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 "CanvasCaptureMediaStream.h"
+#include "DOMMediaStream.h"
+#include "gfxPlatform.h"
+#include "ImageContainer.h"
+#include "MediaStreamGraph.h"
+#include "mozilla/dom/CanvasCaptureMediaStreamBinding.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/Atomics.h"
+#include "nsContentUtils.h"
+
+using namespace mozilla::layers;
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace dom {
+
+class OutputStreamDriver::StreamListener : public MediaStreamListener
+{
+public:
+  explicit StreamListener(OutputStreamDriver* aDriver,
+                          TrackID aTrackId,
+                          PrincipalHandle aPrincipalHandle,
+                          SourceMediaStream* aSourceStream)
+    : mEnded(false)
+    , mSourceStream(aSourceStream)
+    , mTrackId(aTrackId)
+    , mPrincipalHandle(aPrincipalHandle)
+    , mMutex("CanvasCaptureMediaStream OutputStreamDriver::StreamListener")
+    , mImage(nullptr)
+  {
+    MOZ_ASSERT(mSourceStream);
+  }
+
+  void EndStream() {
+    mEnded = true;
+  }
+
+  void SetImage(const RefPtr<layers::Image>& aImage)
+  {
+    MutexAutoLock lock(mMutex);
+    mImage = aImage;
+  }
+
+  void NotifyPull(MediaStreamGraph* aGraph, StreamTime aDesiredTime) override
+  {
+    // Called on the MediaStreamGraph thread.
+    StreamTime delta = aDesiredTime - mSourceStream->GetEndOfAppendedData(mTrackId);
+    if (delta > 0) {
+      MutexAutoLock lock(mMutex);
+      MOZ_ASSERT(mSourceStream);
+
+      RefPtr<Image> image = mImage;
+      IntSize size = image ? image->GetSize() : IntSize(0, 0);
+      VideoSegment segment;
+      segment.AppendFrame(image.forget(), delta, size, mPrincipalHandle);
+
+      mSourceStream->AppendToTrack(mTrackId, &segment);
+    }
+
+    if (mEnded) {
+      mSourceStream->EndAllTrackAndFinish();
+    }
+  }
+
+protected:
+  ~StreamListener() { }
+
+private:
+  Atomic<bool> mEnded;
+  const RefPtr<SourceMediaStream> mSourceStream;
+  const TrackID mTrackId;
+  const PrincipalHandle mPrincipalHandle;
+
+  Mutex mMutex;
+  // The below members are protected by mMutex.
+  RefPtr<layers::Image> mImage;
+};
+
+OutputStreamDriver::OutputStreamDriver(SourceMediaStream* aSourceStream,
+                                       const TrackID& aTrackId,
+                                       const PrincipalHandle& aPrincipalHandle)
+  : FrameCaptureListener()
+  , mSourceStream(aSourceStream)
+  , mStreamListener(new StreamListener(this, aTrackId, aPrincipalHandle,
+                                       aSourceStream))
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mSourceStream);
+  mSourceStream->AddListener(mStreamListener);
+  mSourceStream->AddTrack(aTrackId, 0, new VideoSegment());
+  mSourceStream->AdvanceKnownTracksTime(STREAM_TIME_MAX);
+  mSourceStream->SetPullEnabled(true);
+
+  // All CanvasCaptureMediaStreams shall at least get one frame.
+  mFrameCaptureRequested = true;
+}
+
+OutputStreamDriver::~OutputStreamDriver()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mStreamListener) {
+    // MediaStreamGraph will keep the listener alive until it can finish the
+    // stream on the next NotifyPull().
+    mStreamListener->EndStream();
+  }
+}
+
+void
+OutputStreamDriver::SetImage(const RefPtr<layers::Image>& aImage)
+{
+  if (mStreamListener) {
+    mStreamListener->SetImage(aImage);
+  }
+}
+
+// ----------------------------------------------------------------------
+
+class TimerDriver : public OutputStreamDriver
+{
+public:
+  explicit TimerDriver(SourceMediaStream* aSourceStream,
+                       const double& aFPS,
+                       const TrackID& aTrackId,
+                       const PrincipalHandle& aPrincipalHandle)
+    : OutputStreamDriver(aSourceStream, aTrackId, aPrincipalHandle)
+    , mFPS(aFPS)
+    , mTimer(nullptr)
+  {
+    if (mFPS == 0.0) {
+      return;
+    }
+
+    mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+    if (!mTimer) {
+      return;
+    }
+    mTimer->InitWithFuncCallback(&TimerTick, this, int(1000 / mFPS), nsITimer::TYPE_REPEATING_SLACK);
+  }
+
+  static void TimerTick(nsITimer* aTimer, void* aClosure)
+  {
+    MOZ_ASSERT(aClosure);
+    TimerDriver* driver = static_cast<TimerDriver*>(aClosure);
+
+    driver->RequestFrameCapture();
+  }
+
+  void NewFrame(already_AddRefed<Image> aImage) override
+  {
+    RefPtr<Image> image = aImage;
+
+    if (!mFrameCaptureRequested) {
+      return;
+    }
+
+    mFrameCaptureRequested = false;
+    SetImage(image.forget());
+  }
+
+  void Forget() override
+  {
+    if (mTimer) {
+      mTimer->Cancel();
+      mTimer = nullptr;
+    }
+  }
+
+protected:
+  virtual ~TimerDriver() {}
+
+private:
+  const double mFPS;
+  nsCOMPtr<nsITimer> mTimer;
+};
+
+// ----------------------------------------------------------------------
+
+class AutoDriver : public OutputStreamDriver
+{
+public:
+  explicit AutoDriver(SourceMediaStream* aSourceStream,
+                      const TrackID& aTrackId,
+                      const PrincipalHandle& aPrincipalHandle)
+    : OutputStreamDriver(aSourceStream, aTrackId, aPrincipalHandle) {}
+
+  void NewFrame(already_AddRefed<Image> aImage) override
+  {
+    // Don't reset `mFrameCaptureRequested` since AutoDriver shall always have
+    // `mFrameCaptureRequested` set to true.
+    // This also means we should accept every frame as NewFrame is called only
+    // after something changed.
+
+    RefPtr<Image> image = aImage;
+    SetImage(image.forget());
+  }
+
+protected:
+  virtual ~AutoDriver() {}
+};
+
+// ----------------------------------------------------------------------
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(CanvasCaptureMediaStream, DOMMediaStream,
+                                   mCanvas)
+
+NS_IMPL_ADDREF_INHERITED(CanvasCaptureMediaStream, DOMMediaStream)
+NS_IMPL_RELEASE_INHERITED(CanvasCaptureMediaStream, DOMMediaStream)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(CanvasCaptureMediaStream)
+NS_INTERFACE_MAP_END_INHERITING(DOMMediaStream)
+
+CanvasCaptureMediaStream::CanvasCaptureMediaStream(nsPIDOMWindowInner* aWindow,
+                                                   HTMLCanvasElement* aCanvas)
+  : DOMMediaStream(aWindow, nullptr)
+  , mCanvas(aCanvas)
+  , mOutputStreamDriver(nullptr)
+{
+}
+
+CanvasCaptureMediaStream::~CanvasCaptureMediaStream()
+{
+  if (mOutputStreamDriver) {
+    mOutputStreamDriver->Forget();
+  }
+}
+
+JSObject*
+CanvasCaptureMediaStream::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return dom::CanvasCaptureMediaStreamBinding::Wrap(aCx, this, aGivenProto);
+}
+
+void
+CanvasCaptureMediaStream::RequestFrame()
+{
+  if (mOutputStreamDriver) {
+    mOutputStreamDriver->RequestFrameCapture();
+  }
+}
+
+nsresult
+CanvasCaptureMediaStream::Init(const dom::Optional<double>& aFPS,
+                               const TrackID& aTrackId,
+                               nsIPrincipal* aPrincipal)
+{
+  PrincipalHandle principalHandle = MakePrincipalHandle(aPrincipal);
+
+  if (!aFPS.WasPassed()) {
+    mOutputStreamDriver =
+      new AutoDriver(GetInputStream()->AsSourceStream(), aTrackId, principalHandle);
+  } else if (aFPS.Value() < 0) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  } else {
+    // Cap frame rate to 60 FPS for sanity
+    double fps = std::min(60.0, aFPS.Value());
+    mOutputStreamDriver =
+      new TimerDriver(GetInputStream()->AsSourceStream(), fps, aTrackId, principalHandle);
+  }
+  return NS_OK;
+}
+
+already_AddRefed<CanvasCaptureMediaStream>
+CanvasCaptureMediaStream::CreateSourceStream(nsPIDOMWindowInner* aWindow,
+                                             HTMLCanvasElement* aCanvas)
+{
+  RefPtr<CanvasCaptureMediaStream> stream = new CanvasCaptureMediaStream(aWindow, aCanvas);
+  MediaStreamGraph* graph =
+    MediaStreamGraph::GetInstance(MediaStreamGraph::SYSTEM_THREAD_DRIVER,
+                                  AudioChannel::Normal);
+  stream->InitSourceStream(graph);
+  return stream.forget();
+}
+
+FrameCaptureListener*
+CanvasCaptureMediaStream::FrameCaptureListener()
+{
+  return mOutputStreamDriver;
+}
+
+void
+CanvasCaptureMediaStream::StopCapture()
+{
+  if (!mOutputStreamDriver) {
+    return;
+  }
+
+  mOutputStreamDriver->Forget();
+  mOutputStreamDriver = nullptr;
+}
+
+} // namespace dom
+} // namespace mozilla
+