Add m-esr52 at 52.6.0

1 files changed, 418 insertions, 0 deletions

diff --git a/dom/media/TextTrackCue.h b/dom/media/TextTrackCue.h
new file mode 100644
index 000000000..9c19c70b1
--- /dev/null
+++ b/dom/media/TextTrackCue.h
@@ -0,0 +1,418 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 et tw=78: */
+/* 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 mozilla_dom_TextTrackCue_h
+#define mozilla_dom_TextTrackCue_h
+
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/dom/DocumentFragment.h"
+#include "mozilla/dom/VTTCueBinding.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIWebVTTParserWrapper.h"
+#include "mozilla/StaticPtr.h"
+#include "nsIDocument.h"
+#include "mozilla/dom/HTMLDivElement.h"
+#include "mozilla/dom/TextTrack.h"
+#include "mozilla/StateWatching.h"
+
+namespace mozilla {
+namespace dom {
+
+class HTMLTrackElement;
+class TextTrackRegion;
+
+class TextTrackCue final : public DOMEventTargetHelper
+{
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(TextTrackCue, DOMEventTargetHelper)
+
+  // TextTrackCue WebIDL
+  // See bug 868509 about splitting out the WebVTT-specific interfaces.
+  static already_AddRefed<TextTrackCue>
+  Constructor(GlobalObject& aGlobal,
+              double aStartTime,
+              double aEndTime,
+              const nsAString& aText,
+              ErrorResult& aRv)
+  {
+    nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal.GetAsSupports());
+    RefPtr<TextTrackCue> ttcue = new TextTrackCue(window, aStartTime,
+                                                    aEndTime, aText, aRv);
+    return ttcue.forget();
+  }
+  TextTrackCue(nsPIDOMWindowInner* aGlobal, double aStartTime, double aEndTime,
+               const nsAString& aText, ErrorResult& aRv);
+
+  TextTrackCue(nsPIDOMWindowInner* aGlobal, double aStartTime, double aEndTime,
+               const nsAString& aText, HTMLTrackElement* aTrackElement,
+               ErrorResult& aRv);
+
+  JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+  TextTrack* GetTrack() const
+  {
+    return mTrack;
+  }
+
+  void GetId(nsAString& aId) const
+  {
+    aId = mId;
+  }
+
+  void SetId(const nsAString& aId)
+  {
+    if (mId == aId) {
+      return;
+    }
+
+    mId = aId;
+  }
+
+  double StartTime() const
+  {
+    return mStartTime;
+  }
+
+  void SetStartTime(double aStartTime)
+  {
+    if (mStartTime == aStartTime) {
+      return;
+    }
+
+    mStartTime = aStartTime;
+    mReset = true;
+    NotifyCueUpdated(this);
+  }
+
+  double EndTime() const
+  {
+    return mEndTime;
+  }
+
+  void SetEndTime(double aEndTime)
+  {
+    if (mEndTime == aEndTime) {
+      return;
+    }
+
+    mEndTime = aEndTime;
+    mReset = true;
+    NotifyCueUpdated(this);
+  }
+
+  bool PauseOnExit()
+  {
+    return mPauseOnExit;
+  }
+
+  void SetPauseOnExit(bool aPauseOnExit)
+  {
+    if (mPauseOnExit == aPauseOnExit) {
+      return;
+    }
+
+    mPauseOnExit = aPauseOnExit;
+    NotifyCueUpdated(nullptr);
+  }
+
+  TextTrackRegion* GetRegion();
+  void SetRegion(TextTrackRegion* aRegion);
+
+  DirectionSetting Vertical() const
+  {
+    return mVertical;
+  }
+
+  void SetVertical(const DirectionSetting& aVertical)
+  {
+    if (mVertical == aVertical) {
+      return;
+    }
+
+    mReset = true;
+    mVertical = aVertical;
+  }
+
+  bool SnapToLines()
+  {
+    return mSnapToLines;
+  }
+
+  void SetSnapToLines(bool aSnapToLines)
+  {
+    if (mSnapToLines == aSnapToLines) {
+      return;
+    }
+
+    mReset = true;
+    mSnapToLines = aSnapToLines;
+  }
+
+  void GetLine(OwningDoubleOrAutoKeyword& aLine) const
+  {
+    if (mLineIsAutoKeyword) {
+      aLine.SetAsAutoKeyword() = AutoKeyword::Auto;
+      return;
+    }
+    aLine.SetAsDouble() = mLine;
+  }
+
+  void SetLine(const DoubleOrAutoKeyword& aLine)
+  {
+    if (aLine.IsDouble() &&
+        (mLineIsAutoKeyword || (aLine.GetAsDouble() != mLine))) {
+      mLineIsAutoKeyword = false;
+      mLine = aLine.GetAsDouble();
+      mReset = true;
+      return;
+    }
+    if (aLine.IsAutoKeyword() && !mLineIsAutoKeyword) {
+      mLineIsAutoKeyword = true;
+      mReset = true;
+    }
+  }
+
+  LineAlignSetting LineAlign() const
+  {
+    return mLineAlign;
+  }
+
+  void SetLineAlign(LineAlignSetting& aLineAlign, ErrorResult& aRv)
+  {
+    if (mLineAlign == aLineAlign) {
+      return;
+    }
+
+    mReset = true;
+    mLineAlign = aLineAlign;
+  }
+
+  void GetPosition(OwningDoubleOrAutoKeyword& aPosition) const
+  {
+    if (mPositionIsAutoKeyword) {
+      aPosition.SetAsAutoKeyword() = AutoKeyword::Auto;
+      return;
+    }
+    aPosition.SetAsDouble() = mPosition;
+  }
+
+  void SetPosition(const DoubleOrAutoKeyword& aPosition, ErrorResult& aRv)
+  {
+    if (!aPosition.IsAutoKeyword() &&
+        (aPosition.GetAsDouble() > 100.0 || aPosition.GetAsDouble() < 0.0)){
+      aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+      return;
+    }
+
+    if (aPosition.IsDouble() &&
+        (mPositionIsAutoKeyword || (aPosition.GetAsDouble() != mPosition))) {
+      mPositionIsAutoKeyword = false;
+      mPosition = aPosition.GetAsDouble();
+      mReset = true;
+      return;
+    }
+
+    if (aPosition.IsAutoKeyword() && !mPositionIsAutoKeyword) {
+      mPositionIsAutoKeyword = true;
+      mReset = true;
+    }
+  }
+
+  PositionAlignSetting PositionAlign() const
+  {
+    return mPositionAlign;
+  }
+
+  void SetPositionAlign(PositionAlignSetting aPositionAlign, ErrorResult& aRv)
+  {
+    if (mPositionAlign == aPositionAlign) {
+      return;
+    }
+
+    mReset = true;
+    mPositionAlign = aPositionAlign;
+  }
+
+  double Size() const
+  {
+    return mSize;
+  }
+
+  void SetSize(double aSize, ErrorResult& aRv)
+  {
+    if (mSize == aSize) {
+      return;
+    }
+
+    if (aSize < 0.0 || aSize > 100.0) {
+      aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+      return;
+    }
+
+    mReset = true;
+    mSize = aSize;
+  }
+
+  AlignSetting Align() const
+  {
+    return mAlign;
+  }
+
+  void SetAlign(AlignSetting& aAlign)
+  {
+    if (mAlign == aAlign) {
+      return;
+    }
+
+    mReset = true;
+    mAlign = aAlign;
+  }
+
+  void GetText(nsAString& aText) const
+  {
+    aText = mText;
+  }
+
+  void SetText(const nsAString& aText)
+  {
+    if (mText == aText) {
+      return;
+    }
+
+    mReset = true;
+    mText = aText;
+  }
+
+  IMPL_EVENT_HANDLER(enter)
+  IMPL_EVENT_HANDLER(exit)
+
+  HTMLDivElement* GetDisplayState()
+  {
+    return static_cast<HTMLDivElement*>(mDisplayState.get());
+  }
+
+  void SetDisplayState(HTMLDivElement* aDisplayState)
+  {
+    mDisplayState = aDisplayState;
+    mReset = false;
+  }
+
+  void Reset()
+  {
+    mReset = true;
+  }
+
+  bool HasBeenReset()
+  {
+    return mReset;
+  }
+
+  double ComputedLine();
+  double ComputedPosition();
+  PositionAlignSetting ComputedPositionAlign();
+
+  // Helper functions for implementation.
+  const nsAString& Id() const
+  {
+    return mId;
+  }
+
+  void SetTrack(TextTrack* aTextTrack)
+  {
+    mTrack = aTextTrack;
+    if (!mHaveStartedWatcher && aTextTrack) {
+      mHaveStartedWatcher = true;
+      mWatchManager.Watch(mReset, &TextTrackCue::NotifyDisplayStatesChanged);
+    } else if (mHaveStartedWatcher && !aTextTrack) {
+      mHaveStartedWatcher = false;
+      mWatchManager.Unwatch(mReset, &TextTrackCue::NotifyDisplayStatesChanged);
+    }
+  }
+
+  /**
+   * Produces a tree of anonymous content based on the tree of the processed
+   * cue text.
+   *
+   * Returns a DocumentFragment that is the head of the tree of anonymous
+   * content.
+   */
+  already_AddRefed<DocumentFragment> GetCueAsHTML();
+
+  void SetTrackElement(HTMLTrackElement* aTrackElement);
+
+  void SetActive(bool aActive)
+  {
+    if (mActive == aActive) {
+      return;
+    }
+
+    mActive = aActive;
+    mDisplayState = mActive ? mDisplayState : nullptr;
+  }
+
+  bool GetActive()
+  {
+    return mActive;
+  }
+
+private:
+  ~TextTrackCue();
+
+  void NotifyCueUpdated(TextTrackCue* aCue)
+  {
+    if (mTrack) {
+      mTrack->NotifyCueUpdated(aCue);
+    }
+  }
+
+  void NotifyDisplayStatesChanged();
+
+  void SetDefaultCueSettings();
+  nsresult StashDocument();
+
+  RefPtr<nsIDocument> mDocument;
+  nsString mText;
+  double mStartTime;
+  double mEndTime;
+
+  RefPtr<TextTrack> mTrack;
+  RefPtr<HTMLTrackElement> mTrackElement;
+  nsString mId;
+  MOZ_INIT_OUTSIDE_CTOR double mPosition;
+  bool mPositionIsAutoKeyword;
+  PositionAlignSetting mPositionAlign;
+  double mSize;
+  bool mPauseOnExit;
+  bool mSnapToLines;
+  RefPtr<TextTrackRegion> mRegion;
+  DirectionSetting mVertical;
+  bool mLineIsAutoKeyword;
+  MOZ_INIT_OUTSIDE_CTOR double mLine;
+  AlignSetting mAlign;
+  LineAlignSetting mLineAlign;
+
+  // Holds the computed DOM elements that represent the parsed cue text.
+  // http://www.whatwg.org/specs/web-apps/current-work/#text-track-cue-display-state
+  RefPtr<nsGenericHTMLElement> mDisplayState;
+  // Tells whether or not we need to recompute mDisplayState. This is set
+  // anytime a property that relates to the display of the TextTrackCue is
+  // changed.
+  Watchable<bool> mReset;
+
+  bool mActive;
+
+  static StaticRefPtr<nsIWebVTTParserWrapper> sParserWrapper;
+
+  // Only start watcher after the cue has text track.
+  bool mHaveStartedWatcher;
+  WatchManager<TextTrackCue> mWatchManager;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_TextTrackCue_h