Bug 841493 - Move HTMLMediaElement to WebIDL, r=Ms2ger

content/html/content/public/HTMLMediaElement.h

@@ -27,6 +27,8 @@
 #include "DecoderTraits.h"
 #include "MediaMetadataManager.h"
 #include "AudioChannelAgent.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ErrorResult.h"
 
 // Define to output information on decoding and painting framerate
 /* #define DEBUG_FRAME_RATE 1 */
@@ -42,6 +44,8 @@ class MediaDecoder;
 namespace mozilla {
 namespace dom {
 
+class MediaError;
+
 class HTMLMediaElement : public nsGenericHTMLElement,
                          public nsIObserver,
                          public MediaDecoderOwner,
@@ -318,12 +322,194 @@ public:
    */
   virtual void FireTimeUpdate(bool aPeriodic) MOZ_FINAL MOZ_OVERRIDE;
 
-  MediaStream* GetSrcMediaStream()
+  MediaStream* GetSrcMediaStream() const
   {
     NS_ASSERTION(mSrcStream, "Don't call this when not playing a stream");
     return mSrcStream->GetStream();
   }
 
+  // WebIDL
+
+  MediaError* GetError() const
+  {
+    return mError;
+  }
+
+  // XPCOM GetSrc() is OK
+  void SetSrc(const nsAString& aSrc, ErrorResult& aRv)
+  {
+    SetHTMLAttr(nsGkAtoms::src, aSrc, aRv);
+  }
+
+  // XPCOM GetCurrentSrc() is OK
+
+  // XPCOM GetCrossorigin() is OK
+  void SetCrossorigin(const nsAString& aValue, ErrorResult& aRv)
+  {
+    SetHTMLAttr(nsGkAtoms::crossorigin, aValue, aRv);
+  }
+
+  uint16_t NetworkState() const
+  {
+    return mNetworkState;
+  }
+
+  // XPCOM GetPreload() is OK
+  void SetPreload(const nsAString& aValue, ErrorResult& aRv)
+  {
+    SetHTMLAttr(nsGkAtoms::preload, aValue, aRv);
+  }
+
+  already_AddRefed<TimeRanges> Buffered() const;
+
+  // XPCOM Load() is OK
+
+  // XPCOM CanPlayType() is OK
+
+  uint16_t ReadyState() const
+  {
+    return mReadyState;
+  }
+
+  bool Seeking() const;
+
+  double CurrentTime() const;
+
+  void SetCurrentTime(double aCurrentTime, ErrorResult& aRv);
+
+  double Duration() const;
+
+  bool Paused() const
+  {
+    return mPaused;
+  }
+
+  double DefaultPlaybackRate() const
+  {
+    return mDefaultPlaybackRate;
+  }
+
+  void SetDefaultPlaybackRate(double aDefaultPlaybackRate, ErrorResult& aRv);
+
+  double PlaybackRate() const
+  {
+    return mPlaybackRate;
+  }
+
+  void SetPlaybackRate(double aPlaybackRate, ErrorResult& aRv);
+
+  already_AddRefed<TimeRanges> Played();
+
+  already_AddRefed<TimeRanges> Seekable() const;
+
+  bool Ended();
+
+  bool Autoplay() const
+  {
+    return GetBoolAttr(nsGkAtoms::autoplay);
+  }
+
+  void SetAutoplay(bool aValue, ErrorResult& aRv)
+  {
+    SetHTMLBoolAttr(nsGkAtoms::autoplay, aValue, aRv);
+  }
+
+  bool Loop() const
+  {
+    return GetBoolAttr(nsGkAtoms::loop);
+  }
+
+  void SetLoop(bool aValue, ErrorResult& aRv)
+  {
+    SetHTMLBoolAttr(nsGkAtoms::loop, aValue, aRv);
+  }
+
+  void Play(ErrorResult& aRv);
+
+  void Pause(ErrorResult& aRv);
+
+  bool Controls() const
+  {
+    return GetBoolAttr(nsGkAtoms::controls);
+  }
+
+  void SetControls(bool aValue, ErrorResult& aRv)
+  {
+    SetHTMLBoolAttr(nsGkAtoms::controls, aValue, aRv);
+  }
+
+  double Volume() const
+  {
+    return mVolume;
+  }
+
+  void SetVolume(double aVolume, ErrorResult& aRv);
+
+  bool Muted() const
+  {
+    return mMuted;
+  }
+
+  // XPCOM SetMuted() is OK
+
+  bool DefaultMuted() const
+  {
+    return GetBoolAttr(nsGkAtoms::muted);
+  }
+
+  void SetDefaultMuted(bool aMuted, ErrorResult& aRv)
+  {
+    SetHTMLBoolAttr(nsGkAtoms::muted, aMuted, aRv);
+  }
+
+  already_AddRefed<DOMMediaStream> GetMozSrcObject() const;
+
+  void SetMozSrcObject(DOMMediaStream& aValue);
+
+  double InitialTime();
+
+  bool MozPreservesPitch() const
+  {
+    return mPreservesPitch;
+  }
+
+  // XPCOM MozPreservesPitch() is OK
+
+  bool MozAutoplayEnabled() const
+  {
+    return mAutoplayEnabled;
+  }
+
+  already_AddRefed<DOMMediaStream> MozCaptureStream(ErrorResult& aRv);
+
+  already_AddRefed<DOMMediaStream> MozCaptureStreamUntilEnded(ErrorResult& aRv);
+
+  bool MozAudioCaptured() const
+  {
+    return mAudioCaptured;
+  }
+
+  uint32_t GetMozChannels(ErrorResult& aRv) const;
+
+  uint32_t GetMozSampleRate(ErrorResult& aRv) const;
+
+  uint32_t GetMozFrameBufferLength(ErrorResult& aRv) const;
+
+  void SetMozFrameBufferLength(uint32_t aValue, ErrorResult& aRv);
+
+  JSObject* MozGetMetadata(JSContext* aCx, ErrorResult& aRv);
+
+  void MozLoadFrom(HTMLMediaElement& aOther, ErrorResult& aRv);
+
+  double MozFragmentEnd();
+
+  // XPCOM GetMozAudioChannelType() is OK
+
+  void SetMozAudioChannelType(const nsAString& aValue, ErrorResult& aRv)
+  {
+    SetHTMLAttr(nsGkAtoms::mozaudiochannel, aValue, aRv);
+  }
+
 protected:
   class MediaLoadListener;
   class StreamListener;
@@ -335,7 +521,7 @@ protected:
   public:
     WakeLockBoolWrapper(bool val = false) : mValue(val), mOuter(NULL), mWakeLock(NULL) {}
     void SetOuter(HTMLMediaElement* outer) { mOuter = outer; }
-    operator bool() { return mValue; }
+    operator bool() const { return mValue; }
     WakeLockBoolWrapper& operator=(bool val);
     bool operator !() const { return !mValue; }
   private:
@@ -654,7 +840,7 @@ protected:
   nsCOMPtr<nsIChannel> mChannel;
 
   // Error attribute
-  nsCOMPtr<nsIDOMMediaError> mError;
+  nsRefPtr<MediaError> mError;
 
   // The current media load ID. This is incremented every time we start a
   // new load. Async events note the ID when they're first sent, and only fire

content/html/content/src/HTMLMediaElement.cpp

@@ -5,6 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/dom/HTMLMediaElement.h"
+#include "mozilla/dom/HTMLMediaElementBinding.h"
 #include "mozilla/MathAlgorithms.h"
 #include "mozilla/Util.h"
 
@@ -442,21 +443,35 @@ NS_IMPL_BOOL_ATTR(HTMLMediaElement, DefaultMuted, muted)
 NS_IMPL_ENUM_ATTR_DEFAULT_VALUE(HTMLMediaElement, Preload, preload, NULL)
 NS_IMPL_ENUM_ATTR_DEFAULT_VALUE(HTMLMediaElement, MozAudioChannelType, mozaudiochannel, "normal")
 
-NS_IMETHODIMP
+already_AddRefed<DOMMediaStream>
-HTMLMediaElement::GetMozSrcObject(nsIDOMMediaStream** aStream)
+HTMLMediaElement::GetMozSrcObject() const
 {
   NS_ASSERTION(!mSrcAttrStream || mSrcAttrStream->GetStream(),
                "MediaStream should have been set up properly");
   nsRefPtr<DOMMediaStream> stream = mSrcAttrStream;
+  return stream.forget();
+}
+
+NS_IMETHODIMP
+HTMLMediaElement::GetMozSrcObject(nsIDOMMediaStream** aStream)
+{
+  nsRefPtr<DOMMediaStream> stream = GetMozSrcObject();
   stream.forget(aStream);
   return NS_OK;
 }
 
+void
+HTMLMediaElement::SetMozSrcObject(DOMMediaStream& aValue)
+{
+  mSrcAttrStream = &aValue;
+  Load();
+}
+
 NS_IMETHODIMP
 HTMLMediaElement::SetMozSrcObject(nsIDOMMediaStream* aStream)
 {
-  mSrcAttrStream = static_cast<DOMMediaStream*>(aStream);
+  DOMMediaStream* stream = static_cast<DOMMediaStream*>(aStream);
-  Load();
+  SetMozSrcObject(*stream);
   return NS_OK;
 }
 
@@ -477,13 +492,23 @@ NS_IMETHODIMP HTMLMediaElement::GetError(nsIDOMMediaError * *aError)
 }
 
 /* readonly attribute boolean ended; */
-NS_IMETHODIMP HTMLMediaElement::GetEnded(bool *aEnded)
+bool
+HTMLMediaElement::Ended()
 {
   if (mSrcStream) {
-    *aEnded = GetSrcMediaStream()->IsFinished();
+    return GetSrcMediaStream()->IsFinished();
-  } else if (mDecoder) {
-    *aEnded = mDecoder->IsEnded();
   }
+
+  if (mDecoder) {
+    return mDecoder->IsEnded();
+  }
+
+  return false;
+}
+
+NS_IMETHODIMP HTMLMediaElement::GetEnded(bool* aEnded)
+{
+  *aEnded = Ended();
   return NS_OK;
 }
 
@@ -499,8 +524,7 @@ NS_IMETHODIMP HTMLMediaElement::GetCurrentSrc(nsAString & aCurrentSrc)
 /* readonly attribute unsigned short networkState; */
 NS_IMETHODIMP HTMLMediaElement::GetNetworkState(uint16_t* aNetworkState)
 {
-  *aNetworkState = mNetworkState;
+  *aNetworkState = NetworkState();
-
   return NS_OK;
 }
 
@@ -682,6 +706,7 @@ NS_IMETHODIMP HTMLMediaElement::Load()
 {
   if (mIsRunningLoadMethod)
     return NS_OK;
+
   SetPlayedOrSeeked(false);
   mIsRunningLoadMethod = true;
   AbortExistingLoads();
@@ -689,6 +714,7 @@ NS_IMETHODIMP HTMLMediaElement::Load()
   QueueSelectResourceTask();
   ResetState();
   mIsRunningLoadMethod = false;
+
   return NS_OK;
 }
 
@@ -1173,79 +1199,110 @@ nsresult HTMLMediaElement::LoadWithChannel(nsIChannel *aChannel,
   return NS_OK;
 }
 
-NS_IMETHODIMP HTMLMediaElement::MozLoadFrom(nsIDOMHTMLMediaElement* aOther)
+void
+HTMLMediaElement::MozLoadFrom(HTMLMediaElement& aOther, ErrorResult& aRv)
 {
-  NS_ENSURE_ARG_POINTER(aOther);
-
   // Make sure we don't reenter during synchronous abort events.
-  if (mIsRunningLoadMethod)
+  if (mIsRunningLoadMethod) {
-    return NS_OK;
+    return;
+  }
+
   mIsRunningLoadMethod = true;
   AbortExistingLoads();
   mIsRunningLoadMethod = false;
 
-  nsCOMPtr<nsIContent> content = do_QueryInterface(aOther);
+  if (!aOther.mDecoder) {
-  HTMLMediaElement* other = static_cast<HTMLMediaElement*>(content.get());
+    return;
-  if (!other || !other->mDecoder)
+  }
-    return NS_OK;
 
   ChangeDelayLoadStatus(true);
 
-  mLoadingSrc = other->mLoadingSrc;
+  mLoadingSrc = aOther.mLoadingSrc;
-  nsresult rv = InitializeDecoderAsClone(other->mDecoder);
+  aRv = InitializeDecoderAsClone(aOther.mDecoder);
-  if (NS_FAILED(rv)) {
+  if (aRv.Failed()) {
     ChangeDelayLoadStatus(false);
-    return rv;
+    return;
   }
 
   SetPlaybackRate(mDefaultPlaybackRate);
   DispatchAsyncEvent(NS_LITERAL_STRING("loadstart"));
+}
 
-  return NS_OK;
+NS_IMETHODIMP HTMLMediaElement::MozLoadFrom(nsIDOMHTMLMediaElement* aOther)
+{
+  NS_ENSURE_ARG_POINTER(aOther);
+
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aOther);
+  HTMLMediaElement* other = static_cast<HTMLMediaElement*>(content.get());
+
+  if (!other) {
+    return NS_ERROR_FAILURE;
+  }
+
+  ErrorResult rv;
+  MozLoadFrom(*other, rv);
+
+  return rv.ErrorCode();
 }
 
 /* readonly attribute unsigned short readyState; */
 NS_IMETHODIMP HTMLMediaElement::GetReadyState(uint16_t* aReadyState)
 {
-  *aReadyState = mReadyState;
+  *aReadyState = ReadyState();
 
   return NS_OK;
 }
 
 /* readonly attribute boolean seeking; */
+bool
+HTMLMediaElement::Seeking() const
+{
+  return mDecoder && mDecoder->IsSeeking();
+}
+
 NS_IMETHODIMP HTMLMediaElement::GetSeeking(bool* aSeeking)
 {
-  *aSeeking = mDecoder && mDecoder->IsSeeking();
+  *aSeeking = Seeking();
-
   return NS_OK;
 }
 
 /* attribute double currentTime; */
-NS_IMETHODIMP HTMLMediaElement::GetCurrentTime(double *aCurrentTime)
+double
+HTMLMediaElement::CurrentTime() const
 {
   if (mSrcStream) {
-    *aCurrentTime = MediaTimeToSeconds(GetSrcMediaStream()->GetCurrentTime());
+    return MediaTimeToSeconds(GetSrcMediaStream()->GetCurrentTime());
-  } else if (mDecoder) {
-    *aCurrentTime = mDecoder->GetCurrentTime();
-  } else {
-    *aCurrentTime = 0.0;
   }
+
+  if (mDecoder) {
+    return mDecoder->GetCurrentTime();
+  }
+
+  return 0.0;
+}
+
+NS_IMETHODIMP HTMLMediaElement::GetCurrentTime(double* aCurrentTime)
+{
+  *aCurrentTime = CurrentTime();
   return NS_OK;
 }
 
-NS_IMETHODIMP HTMLMediaElement::SetCurrentTime(double aCurrentTime)
+void
+HTMLMediaElement::SetCurrentTime(double aCurrentTime, ErrorResult& aRv)
 {
+  MOZ_ASSERT(aCurrentTime == aCurrentTime);
+
   StopSuspendingAfterFirstFrame();
 
   if (mSrcStream) {
     // do nothing since streams aren't seekable; we effectively clamp to
     // the current time.
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
   }
 
   if (mCurrentPlayRangeStart != -1.0) {
-    double rangeEndTime = 0;
+    double rangeEndTime = CurrentTime();
-    GetCurrentTime(&rangeEndTime);
     LOG(PR_LOG_DEBUG, ("%p Adding \'played\' a range : [%f, %f]", this, mCurrentPlayRangeStart, rangeEndTime));
     // Multiple seek without playing, or seek while playing.
     if (mCurrentPlayRangeStart != rangeEndTime) {
@@ -1255,18 +1312,14 @@ NS_IMETHODIMP HTMLMediaElement::SetCurrentTime(double aCurrentTime)
 
   if (!mDecoder) {
     LOG(PR_LOG_DEBUG, ("%p SetCurrentTime(%f) failed: no decoder", this, aCurrentTime));
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
   }
 
   if (mReadyState == nsIDOMHTMLMediaElement::HAVE_NOTHING) {
     LOG(PR_LOG_DEBUG, ("%p SetCurrentTime(%f) failed: no source", this, aCurrentTime));
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
-  }
+    return;
-
-  // Detect for a NaN and invalid values.
-  if (aCurrentTime != aCurrentTime) {
-    LOG(PR_LOG_DEBUG, ("%p SetCurrentTime(%f) failed: bad time", this, aCurrentTime));
-    return NS_ERROR_FAILURE;
   }
 
   // Clamp the time to [0, duration] as required by the spec.
@@ -1280,54 +1333,78 @@ NS_IMETHODIMP HTMLMediaElement::SetCurrentTime(double aCurrentTime)
   // The media backend is responsible for dispatching the timeupdate
   // event if it changes the playback position as a result of the seek.
   LOG(PR_LOG_DEBUG, ("%p SetCurrentTime(%f) starting seek", this, aCurrentTime));
-  nsresult rv = mDecoder->Seek(clampedTime);
+  aRv = mDecoder->Seek(clampedTime);
   // Start a new range at position we seeked to.
   mCurrentPlayRangeStart = mDecoder->GetCurrentTime();
 
   // We changed whether we're seeking so we need to AddRemoveSelfReference.
   AddRemoveSelfReference();
+}
 
-  return rv;
+NS_IMETHODIMP HTMLMediaElement::SetCurrentTime(double aCurrentTime)
+{
+  // Detect for a NaN and invalid values.
+  if (aCurrentTime != aCurrentTime) {
+    LOG(PR_LOG_DEBUG, ("%p SetCurrentTime(%f) failed: bad time", this, aCurrentTime));
+    return NS_ERROR_FAILURE;
+  }
+
+  ErrorResult rv;
+  SetCurrentTime(aCurrentTime, rv);
+  return rv.ErrorCode();
 }
 
 /* readonly attribute double duration; */
-NS_IMETHODIMP HTMLMediaElement::GetDuration(double *aDuration)
+double
+HTMLMediaElement::Duration() const
 {
   if (mSrcStream) {
-    *aDuration = std::numeric_limits<double>::infinity();
+    return std::numeric_limits<double>::infinity();
-  } else if (mDecoder) {
-    *aDuration = mDecoder->GetDuration();
-  } else {
-    *aDuration = std::numeric_limits<double>::quiet_NaN();
   }
+
+  if (mDecoder) {
+    return mDecoder->GetDuration();
+  }
+
+  return std::numeric_limits<double>::quiet_NaN();
+}
+
+NS_IMETHODIMP HTMLMediaElement::GetDuration(double* aDuration)
+{
+  *aDuration = Duration();
   return NS_OK;
 }
 
-/* readonly attribute nsIDOMHTMLTimeRanges seekable; */
+already_AddRefed<TimeRanges>
-NS_IMETHODIMP HTMLMediaElement::GetSeekable(nsIDOMTimeRanges** aSeekable)
+HTMLMediaElement::Seekable() const
 {
   nsRefPtr<TimeRanges> ranges = new TimeRanges();
   if (mDecoder && mReadyState > nsIDOMHTMLMediaElement::HAVE_NOTHING) {
     mDecoder->GetSeekable(ranges);
   }
+  return ranges.forget();
+}
+
+/* readonly attribute nsIDOMHTMLTimeRanges seekable; */
+NS_IMETHODIMP HTMLMediaElement::GetSeekable(nsIDOMTimeRanges** aSeekable)
+{
+  nsRefPtr<TimeRanges> ranges = Seekable();
   ranges.forget(aSeekable);
   return NS_OK;
 }
 
-
 /* readonly attribute boolean paused; */
 NS_IMETHODIMP HTMLMediaElement::GetPaused(bool* aPaused)
 {
-  *aPaused = mPaused;
+  *aPaused = Paused();
 
   return NS_OK;
 }
 
-/* readonly attribute nsIDOMHTMLTimeRanges played; */
+already_AddRefed<TimeRanges>
-NS_IMETHODIMP HTMLMediaElement::GetPlayed(nsIDOMTimeRanges** aPlayed)
+HTMLMediaElement::Played()
 {
-  TimeRanges* ranges = new TimeRanges();
+  nsRefPtr<TimeRanges> ranges = new TimeRanges();
-  NS_ADDREF(*aPlayed = ranges);
 
   uint32_t timeRangeCount = 0;
   mPlayed.GetLength(&timeRangeCount);
@@ -1340,25 +1417,34 @@ NS_IMETHODIMP HTMLMediaElement::GetPlayed(nsIDOMTimeRanges** aPlayed)
   }
 
   if (mCurrentPlayRangeStart != -1.0) {
-    double now = 0.0;
+    double now = CurrentTime();
-    GetCurrentTime(&now);
     if (mCurrentPlayRangeStart != now) {
       ranges->Add(mCurrentPlayRangeStart, now);
     }
   }
 
   ranges->Normalize();
+  return ranges.forget();
+}
 
+/* readonly attribute nsIDOMHTMLTimeRanges played; */
+NS_IMETHODIMP HTMLMediaElement::GetPlayed(nsIDOMTimeRanges** aPlayed)
+{
+  nsRefPtr<TimeRanges> ranges = Played();
+  ranges.forget(aPlayed);
   return NS_OK;
 }
 
 /* void pause (); */
-NS_IMETHODIMP HTMLMediaElement::Pause()
+void
+HTMLMediaElement::Pause(ErrorResult& aRv)
 {
   if (mNetworkState == nsIDOMHTMLMediaElement::NETWORK_EMPTY) {
     LOG(PR_LOG_DEBUG, ("Loading due to Pause()"));
-    nsresult rv = Load();
+    aRv = Load();
-    NS_ENSURE_SUCCESS(rv, rv);
+    if (aRv.Failed()) {
+      return;
+    }
   } else if (mDecoder) {
     mDecoder->Pause();
   }
@@ -1376,25 +1462,32 @@ NS_IMETHODIMP HTMLMediaElement::Pause()
     FireTimeUpdate(false);
     DispatchAsyncEvent(NS_LITERAL_STRING("pause"));
   }
+}
 
-  return NS_OK;
+NS_IMETHODIMP HTMLMediaElement::Pause()
+{
+  ErrorResult rv;
+  Pause(rv);
+  return rv.ErrorCode();
 }
 
 /* attribute double volume; */
 NS_IMETHODIMP HTMLMediaElement::GetVolume(double* aVolume)
 {
-  *aVolume = mVolume;
+  *aVolume = Volume();
-
   return NS_OK;
 }
 
-NS_IMETHODIMP HTMLMediaElement::SetVolume(double aVolume)
+void
+HTMLMediaElement::SetVolume(double aVolume, ErrorResult& aRv)
 {
-  if (!(aVolume >= 0.0 && aVolume <= 1.0))
+  if (aVolume < 0.0 || aVolume > 1.0) {
-    return NS_ERROR_DOM_INDEX_SIZE_ERR;
+    aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+    return;
+  }
 
   if (aVolume == mVolume)
-    return NS_OK;
+    return;
 
   mVolume = aVolume;
 
@@ -1409,30 +1502,51 @@ NS_IMETHODIMP HTMLMediaElement::SetVolume(double aVolume)
   }
 
   DispatchAsyncEvent(NS_LITERAL_STRING("volumechange"));
+}
 
-  return NS_OK;
+NS_IMETHODIMP HTMLMediaElement::SetVolume(double aVolume)
+{
+  ErrorResult rv;
+  SetVolume(aVolume, rv);
+  return rv.ErrorCode();
+}
+
+uint32_t
+HTMLMediaElement::GetMozChannels(ErrorResult& aRv) const
+{
+  if (!mDecoder && !mAudioStream) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return 0;
+  }
+
+  return mChannels;
 }
 
 NS_IMETHODIMP
 HTMLMediaElement::GetMozChannels(uint32_t* aMozChannels)
 {
-  if (!mDecoder && !mAudioStream) {
+  ErrorResult rv;
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  *aMozChannels = GetMozChannels(rv);
+ return rv.ErrorCode();
 }
 
-  *aMozChannels = mChannels;
+uint32_t
-  return NS_OK;
+HTMLMediaElement::GetMozSampleRate(ErrorResult& aRv) const
+{
+  if (!mDecoder && !mAudioStream) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return 0;
+  }
+
+  return mRate;
 }
 
 NS_IMETHODIMP
 HTMLMediaElement::GetMozSampleRate(uint32_t* aMozSampleRate)
 {
-  if (!mDecoder && !mAudioStream) {
+  ErrorResult rv;
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  *aMozSampleRate = GetMozSampleRate(rv);
-  }
+  return rv.ErrorCode();
-
-  *aMozSampleRate = mRate;
-  return NS_OK;
 }
 
 // Helper struct with arguments for our hash iterator.
@@ -1467,57 +1581,90 @@ HTMLMediaElement::BuildObjectFromTags(nsCStringHashKey::KeyType aKey,
   return PL_DHASH_NEXT;
 }
 
-NS_IMETHODIMP
+JSObject*
-HTMLMediaElement::MozGetMetadata(JSContext* cx, JS::Value* aValue)
+HTMLMediaElement::MozGetMetadata(JSContext* cx, ErrorResult& aRv)
 {
   if (mReadyState < nsIDOMHTMLMediaElement::HAVE_METADATA) {
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return nullptr;
   }
 
   JSObject* tags = JS_NewObject(cx, NULL, NULL, NULL);
   if (!tags) {
-    return NS_ERROR_FAILURE;
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
   }
   if (mTags) {
     MetadataIterCx iter = {cx, tags, false};
     mTags->EnumerateRead(BuildObjectFromTags, static_cast<void*>(&iter));
     if (iter.error) {
       NS_WARNING("couldn't create metadata object!");
-      return NS_ERROR_FAILURE;
+      aRv.Throw(NS_ERROR_FAILURE);
+      return nullptr;
     }
   }
-  *aValue = OBJECT_TO_JSVAL(tags);
 
-  return NS_OK;
+  return tags;
+}
+
+NS_IMETHODIMP
+HTMLMediaElement::MozGetMetadata(JSContext* cx, JS::Value* aValue)
+{
+  ErrorResult rv;
+
+  JSObject* obj = MozGetMetadata(cx, rv);
+  if (!rv.Failed()) {
+    MOZ_ASSERT(obj);
+    *aValue = JS::ObjectValue(*obj);
+  }
+
+  return rv.ErrorCode();
+}
+
+uint32_t
+HTMLMediaElement::GetMozFrameBufferLength(ErrorResult& aRv) const
+{
+  // The framebuffer (via MozAudioAvailable events) is only available
+  // when reading vs. writing audio directly.
+  if (!mDecoder) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return 0;
+  }
+
+  return mDecoder->GetFrameBufferLength();
 }
 
 NS_IMETHODIMP
 HTMLMediaElement::GetMozFrameBufferLength(uint32_t* aMozFrameBufferLength)
 {
-  // The framebuffer (via MozAudioAvailable events) is only available
+  ErrorResult rv;
-  // when reading vs. writing audio directly.
+  *aMozFrameBufferLength = GetMozFrameBufferLength(rv);
-  if (!mDecoder) {
+  return rv.ErrorCode();
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
 }
 
-  *aMozFrameBufferLength = mDecoder->GetFrameBufferLength();
+void
-  return NS_OK;
+HTMLMediaElement::SetMozFrameBufferLength(uint32_t aMozFrameBufferLength, ErrorResult& aRv)
+{
+  if (!mDecoder) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  aRv = mDecoder->RequestFrameBufferLength(aMozFrameBufferLength);
 }
 
 NS_IMETHODIMP
 HTMLMediaElement::SetMozFrameBufferLength(uint32_t aMozFrameBufferLength)
 {
-  if (!mDecoder)
+  ErrorResult rv;
-    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  SetMozFrameBufferLength(aMozFrameBufferLength, rv);
-
+  return rv.ErrorCode();
-  return mDecoder->RequestFrameBufferLength(aMozFrameBufferLength);
 }
 
 /* attribute boolean muted; */
 NS_IMETHODIMP HTMLMediaElement::GetMuted(bool* aMuted)
 {
-  *aMuted = mMuted;
+  *aMuted = Muted();
-
   return NS_OK;
 }
 
@@ -1543,7 +1690,6 @@ NS_IMETHODIMP HTMLMediaElement::SetMuted(bool aMuted)
   SetMutedInternal(aMuted);
 
   DispatchAsyncEvent(NS_LITERAL_STRING("volumechange"));
-
   return NS_OK;
 }
 
@@ -1575,27 +1721,47 @@ HTMLMediaElement::CaptureStreamInternal(bool aFinishWhenEnded)
   return result.forget();
 }
 
+already_AddRefed<DOMMediaStream>
+HTMLMediaElement::MozCaptureStream(ErrorResult& aRv)
+{
+  nsRefPtr<DOMMediaStream> stream = CaptureStreamInternal(false);
+  if (!stream) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  return stream.forget();
+}
+
 NS_IMETHODIMP HTMLMediaElement::MozCaptureStream(nsIDOMMediaStream** aStream)
 {
-  *aStream = CaptureStreamInternal(false).get();
+  ErrorResult rv;
-  if (!*aStream) {
+  *aStream = MozCaptureStream(rv).get();
-    return NS_ERROR_FAILURE;
+  return rv.ErrorCode();
 }
-  return NS_OK;
+
+already_AddRefed<DOMMediaStream>
+HTMLMediaElement::MozCaptureStreamUntilEnded(ErrorResult& aRv)
+{
+  nsRefPtr<DOMMediaStream> stream = CaptureStreamInternal(true);
+  if (!stream) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  return stream.forget();
 }
 
 NS_IMETHODIMP HTMLMediaElement::MozCaptureStreamUntilEnded(nsIDOMMediaStream** aStream)
 {
-  *aStream = CaptureStreamInternal(true).get();
+  ErrorResult rv;
-  if (!*aStream) {
+  *aStream = MozCaptureStreamUntilEnded(rv).get();
-    return NS_ERROR_FAILURE;
+  return rv.ErrorCode();
-  }
-  return NS_OK;
 }
 
 NS_IMETHODIMP HTMLMediaElement::GetMozAudioCaptured(bool* aCaptured)
 {
-  *aCaptured = mAudioCaptured;
+  *aCaptured = MozAudioCaptured();
   return NS_OK;
 }
 
@@ -1838,14 +2004,17 @@ void HTMLMediaElement::SetPlayedOrSeeked(bool aValue)
                                                       NS_FRAME_IS_DIRTY);
 }
 
-NS_IMETHODIMP HTMLMediaElement::Play()
+void
+HTMLMediaElement::Play(ErrorResult& aRv)
 {
   StopSuspendingAfterFirstFrame();
   SetPlayedOrSeeked(true);
 
   if (mNetworkState == nsIDOMHTMLMediaElement::NETWORK_EMPTY) {
-    nsresult rv = Load();
+    aRv = Load();
-    NS_ENSURE_SUCCESS(rv, rv);
+    if (aRv.Failed()) {
+      return;
+    }
   }
   if (mSuspendedForPreloadNone) {
     ResumeLoad(PRELOAD_ENOUGH);
@@ -1857,13 +2026,15 @@ NS_IMETHODIMP HTMLMediaElement::Play()
       SetCurrentTime(0);
     }
     if (!mPausedForInactiveDocumentOrChannel) {
-      nsresult rv = mDecoder->Play();
+      aRv = mDecoder->Play();
-      NS_ENSURE_SUCCESS(rv, rv);
+      if (aRv.Failed()) {
+        return;
+      }
     }
   }
 
   if (mCurrentPlayRangeStart == -1.0) {
-    GetCurrentTime(&mCurrentPlayRangeStart);
+    mCurrentPlayRangeStart = CurrentTime();
   }
 
   // TODO: If the playback has ended, then the user agent must set
@@ -1897,8 +2068,13 @@ NS_IMETHODIMP HTMLMediaElement::Play()
   // and our preload status.
   AddRemoveSelfReference();
   UpdatePreloadAction();
+}
 
-  return NS_OK;
+NS_IMETHODIMP HTMLMediaElement::Play()
+{
+  ErrorResult rv;
+  Play(rv);
+  return rv.ErrorCode();
 }
 
 HTMLMediaElement::WakeLockBoolWrapper& HTMLMediaElement::WakeLockBoolWrapper::operator=(bool val) {
@@ -2851,7 +3027,7 @@ void HTMLMediaElement::NotifyAutoplayDataReady()
     if (mDecoder) {
       SetPlayedOrSeeked(true);
       if (mCurrentPlayRangeStart == -1.0) {
-        GetCurrentTime(&mCurrentPlayRangeStart);
+        mCurrentPlayRangeStart = CurrentTime();
       }
       mDecoder->Play();
     } else if (mSrcStream) {
@@ -3268,7 +3444,8 @@ HTMLMediaElement::CopyInnerTo(Element* aDest)
   return rv;
 }
 
-nsresult HTMLMediaElement::GetBuffered(nsIDOMTimeRanges** aBuffered)
+already_AddRefed<TimeRanges>
+HTMLMediaElement::Buffered() const
 {
   nsRefPtr<TimeRanges> ranges = new TimeRanges();
   if (mReadyState > nsIDOMHTMLMediaElement::HAVE_NOTHING && mDecoder) {
@@ -3276,6 +3453,12 @@ nsresult HTMLMediaElement::GetBuffered(nsIDOMTimeRanges** aBuffered)
     // time ranges we found up till the error.
     mDecoder->GetBuffered(ranges);
   }
+  return ranges.forget();
+}
+
+nsresult HTMLMediaElement::GetBuffered(nsIDOMTimeRanges** aBuffered)
+{
+  nsRefPtr<TimeRanges> ranges = Buffered();
   ranges.forget(aBuffered);
   return NS_OK;
 }
@@ -3309,8 +3492,7 @@ void HTMLMediaElement::FireTimeUpdate(bool aPeriodic)
   NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
 
   TimeStamp now = TimeStamp::Now();
-  double time = 0;
+  double time = CurrentTime();
-  GetCurrentTime(&time);
 
   // Fire a timeupdate event if this is not a periodic update (i.e. it's a
   // timeupdate event mandated by the spec), or if it's a periodic update
@@ -3342,31 +3524,41 @@ void HTMLMediaElement::GetCurrentSpec(nsCString& aString)
 }
 
 /* attribute double initialTime; */
-NS_IMETHODIMP HTMLMediaElement::GetInitialTime(double *aTime)
+double
+HTMLMediaElement::InitialTime()
 {
   // If there is no start fragment then the initalTime is zero.
   // Clamp to duration if it is greater than duration.
-  double duration = 0.0;
+  double duration = Duration();
-  nsresult rv = GetDuration(&duration);
-  NS_ENSURE_SUCCESS(rv, rv);
 
-  *aTime = mFragmentStart < 0.0 ? 0.0 : mFragmentStart;
+  double time = mFragmentStart < 0.0 ? 0.0 : mFragmentStart;
-  if (*aTime > duration) {
+  if (time > duration) {
-    *aTime = duration;
+    time = duration;
   }
+
+  return time;
+}
+
+NS_IMETHODIMP HTMLMediaElement::GetInitialTime(double* aTime)
+{
+  *aTime = InitialTime();
   return NS_OK;
 }
 
 /* attribute double mozFragmentEnd; */
-NS_IMETHODIMP HTMLMediaElement::GetMozFragmentEnd(double *aTime)
+double
+HTMLMediaElement::MozFragmentEnd()
 {
-  double duration = 0.0;
+  double duration = Duration();
-  nsresult rv = GetDuration(&duration);
-  NS_ENSURE_SUCCESS(rv, rv);
 
   // If there is no end fragment, or the fragment end is greater than the
   // duration, return the duration.
-  *aTime = (mFragmentEnd < 0.0 || mFragmentEnd > duration) ? duration : mFragmentEnd;
+  return (mFragmentEnd < 0.0 || mFragmentEnd > duration) ? duration : mFragmentEnd;
+}
+
+NS_IMETHODIMP HTMLMediaElement::GetMozFragmentEnd(double* aTime)
+{
+  *aTime = MozFragmentEnd();
   return NS_OK;
 }
 
@@ -3394,34 +3586,44 @@ static double ClampPlaybackRate(double aPlaybackRate)
 /* attribute double defaultPlaybackRate; */
 NS_IMETHODIMP HTMLMediaElement::GetDefaultPlaybackRate(double* aDefaultPlaybackRate)
 {
-  *aDefaultPlaybackRate = mDefaultPlaybackRate;
+  *aDefaultPlaybackRate = DefaultPlaybackRate();
   return NS_OK;
 }
 
-NS_IMETHODIMP HTMLMediaElement::SetDefaultPlaybackRate(double aDefaultPlaybackRate)
+void
+HTMLMediaElement::SetDefaultPlaybackRate(double aDefaultPlaybackRate, ErrorResult& aRv)
 {
   if (aDefaultPlaybackRate < 0) {
-    return NS_ERROR_NOT_IMPLEMENTED;
+    aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
+    return;
   }
 
   mDefaultPlaybackRate = ClampPlaybackRate(aDefaultPlaybackRate);
   DispatchAsyncEvent(NS_LITERAL_STRING("ratechange"));
-  return NS_OK;
+}
+
+NS_IMETHODIMP HTMLMediaElement::SetDefaultPlaybackRate(double aDefaultPlaybackRate)
+{
+  ErrorResult rv;
+  SetDefaultPlaybackRate(aDefaultPlaybackRate, rv);
+  return rv.ErrorCode();
 }
 
 /* attribute double playbackRate; */
 NS_IMETHODIMP HTMLMediaElement::GetPlaybackRate(double* aPlaybackRate)
 {
-  *aPlaybackRate = mPlaybackRate;
+  *aPlaybackRate = PlaybackRate();
   return NS_OK;
 }
 
-NS_IMETHODIMP HTMLMediaElement::SetPlaybackRate(double aPlaybackRate)
+void
+HTMLMediaElement::SetPlaybackRate(double aPlaybackRate, ErrorResult& aRv)
 {
   // Changing the playback rate of a media that has more than two channels is
   // not supported.
   if (aPlaybackRate < 0 || (mChannels > 2 && aPlaybackRate != 1.0)) {
-    return NS_ERROR_NOT_IMPLEMENTED;
+    aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
+    return;
   }
 
   mPlaybackRate = ClampPlaybackRate(aPlaybackRate);
@@ -3440,13 +3642,19 @@ NS_IMETHODIMP HTMLMediaElement::SetPlaybackRate(double aPlaybackRate)
     mDecoder->SetPlaybackRate(mPlaybackRate);
   }
   DispatchAsyncEvent(NS_LITERAL_STRING("ratechange"));
-  return NS_OK;
+}
+
+NS_IMETHODIMP HTMLMediaElement::SetPlaybackRate(double aPlaybackRate)
+{
+  ErrorResult rv;
+  SetPlaybackRate(aPlaybackRate, rv);
+  return rv.ErrorCode();
 }
 
 /* attribute bool mozPreservesPitch; */
 NS_IMETHODIMP HTMLMediaElement::GetMozPreservesPitch(bool* aPreservesPitch)
 {
-  *aPreservesPitch = mPreservesPitch;
+  *aPreservesPitch = MozPreservesPitch();
   return NS_OK;
 }
 

content/html/content/test/Makefile.in

@@ -353,6 +353,11 @@ MOCHITEST_FILES = \
 		test_formData.html \
 		$(NULL)
 
+ifdef MOZ_MEDIA
+MOCHITEST_FILES += \
+		test_mozLoadFrom.html \
+		$(NULL)
+endif
 
 MOCHITEST_BROWSER_FILES = \
 		browser_bug649778.js \

content/html/content/test/test_mozLoadFrom.html

@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for mozLoadFrom</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script>
+
+try {
+  document.createElement("video").mozLoadFrom({});
+  ok(false, "This should be throw an exception");
+} catch(e) {
+  ok(true, "This should be throw an exception");
+}
+</script>
+</body>
+</html>

content/media/test/test_constants.html

@@ -156,15 +156,15 @@ is(HTMLElement.prototype.MEDIA_ERR_ABORTED, undefined);
 is(HTMLElement.prototype.MEDIA_ERR_NETWORK, undefined);
 is(HTMLElement.prototype.MEDIA_ERR_DECODE, undefined);
 is(HTMLElement.prototype.MEDIA_ERR_SRC_NOT_SUPPORTED, undefined);
-todo_is(HTMLMediaElement.prototype.NETWORK_EMPTY, 0, "HTMLMediaElement.prototype.NETWORK_EMPTY");
+is(HTMLMediaElement.prototype.NETWORK_EMPTY, 0, "HTMLMediaElement.prototype.NETWORK_EMPTY");
-todo_is(HTMLMediaElement.prototype.NETWORK_IDLE, 1, "HTMLMediaElement.prototype.NETWORK_IDLE");
+is(HTMLMediaElement.prototype.NETWORK_IDLE, 1, "HTMLMediaElement.prototype.NETWORK_IDLE");
-todo_is(HTMLMediaElement.prototype.NETWORK_LOADING, 2, "HTMLMediaElement.prototype.NETWORK_LOADING");
+is(HTMLMediaElement.prototype.NETWORK_LOADING, 2, "HTMLMediaElement.prototype.NETWORK_LOADING");
-todo_is(HTMLMediaElement.prototype.NETWORK_NO_SOURCE, 3, "HTMLMediaElement.prototype.NETWORK_NO_SOURCE");
+is(HTMLMediaElement.prototype.NETWORK_NO_SOURCE, 3, "HTMLMediaElement.prototype.NETWORK_NO_SOURCE");
-todo_is(HTMLMediaElement.prototype.HAVE_NOTHING, 0, "HTMLMediaElement.prototype.HAVE_NOTHING");
+is(HTMLMediaElement.prototype.HAVE_NOTHING, 0, "HTMLMediaElement.prototype.HAVE_NOTHING");
-todo_is(HTMLMediaElement.prototype.HAVE_METADATA, 1, "HTMLMediaElement.prototype.HAVE_METADATA");
+is(HTMLMediaElement.prototype.HAVE_METADATA, 1, "HTMLMediaElement.prototype.HAVE_METADATA");
-todo_is(HTMLMediaElement.prototype.HAVE_CURRENT_DATA, 2, "HTMLMediaElement.prototype.HAVE_CURRENT_DATA");
+is(HTMLMediaElement.prototype.HAVE_CURRENT_DATA, 2, "HTMLMediaElement.prototype.HAVE_CURRENT_DATA");
-todo_is(HTMLMediaElement.prototype.HAVE_FUTURE_DATA, 3, "HTMLMediaElement.prototype.HAVE_FUTURE_DATA");
+is(HTMLMediaElement.prototype.HAVE_FUTURE_DATA, 3, "HTMLMediaElement.prototype.HAVE_FUTURE_DATA");
-todo_is(HTMLMediaElement.prototype.HAVE_ENOUGH_DATA, 4, "HTMLMediaElement.prototype.HAVE_ENOUGH_DATA");
+is(HTMLMediaElement.prototype.HAVE_ENOUGH_DATA, 4, "HTMLMediaElement.prototype.HAVE_ENOUGH_DATA");
 is(HTMLMediaElement.prototype.MEDIA_ERR_ABORTED, undefined, "HTMLMediaElement.prototype.MEDIA_ERR_ABORTED");
 is(HTMLMediaElement.prototype.MEDIA_ERR_NETWORK, undefined, "HTMLMediaElement.prototype.MEDIA_ERR_NETWORK");
 is(HTMLMediaElement.prototype.MEDIA_ERR_DECODE, undefined, "HTMLMediaElement.prototype.MEDIA_ERR_DECODE");

content/media/test/test_streams_srcObject.html

@@ -28,7 +28,7 @@ function doTest() {
     b.mozSrcObject = "invalid";
     ok(false, "Setting mozSrcObject to an invalid value should throw.");
   } catch (e) {
-    todo(e instanceof TypeError, "Exception should be a TypeError");
+    ok(e instanceof TypeError, "Exception should be a TypeError");
   }
   is(b.mozSrcObject, stream, "Stream not set to invalid value");
   is(b.src, newSrc, "src attribute not affected by setting srcObject");

content/media/test/test_volume.html

@@ -13,11 +13,11 @@
 <script class="testbody" type="text/javascript">
 
 function test(element, value, shouldThrow) {
-  var threw = false;
+  var threw = null;
   try {
     element.volume = value;
-  } catch (err if err.name == "IndexSizeError") {
+  } catch (ex) {
-    threw = true;
+    threw = ex.name;
   }
   is(shouldThrow, threw, "Case: " +element.id+ " setVolume=" + value);
 }
@@ -27,12 +27,12 @@ var ids = new Array(document.getElementById('v1'), document.getElementById('a1')
 
 for (i=0; i<ids.length; i++) {
   var element = ids[i];
-  test(element, 0.0, false);
+  test(element, 0.0, null);
-  test(element, 1.0, false);
+  test(element, 1.0, null);
-  test(element, -0.1, true);
+  test(element, -0.1, "IndexSizeError");
-  test(element, 1.1, true);
+  test(element, 1.1, "IndexSizeError");
-  test(element, undefined, true);
+  test(element, undefined, "TypeError");
-  test(element, NaN, true);
+  test(element, NaN, "TypeError");
 }  
  
 </script>

dom/webidl/HTMLMediaElement.webidl

@@ -0,0 +1,181 @@
+/* -*- Mode: IDL; 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/.
+ *
+ * The origin of this IDL file is
+ * http://www.whatwg.org/specs/web-apps/current-work/#media-elements
+ *
+ * © Copyright 2004-2011 Apple Computer, Inc., Mozilla Foundation, and
+ * Opera Software ASA. You are granted a license to use, reproduce
+ * and create derivative works of this document.
+ */
+
+interface HTMLMediaElement : HTMLElement {
+
+  // error state
+  readonly attribute MediaError? error;
+
+  // network state
+  [SetterThrows]
+           attribute DOMString src;
+  readonly attribute DOMString currentSrc;
+
+  // Bug 847370 - crossOrigin vs crossorigin.
+  [SetterThrows]
+           attribute DOMString crossorigin;
+  const unsigned short NETWORK_EMPTY = 0;
+  const unsigned short NETWORK_IDLE = 1;
+  const unsigned short NETWORK_LOADING = 2;
+  const unsigned short NETWORK_NO_SOURCE = 3;
+  readonly attribute unsigned short networkState;
+  [SetterThrows]
+           attribute DOMString preload;
+  [Creator]
+  readonly attribute TimeRanges buffered;
+  void load();
+  DOMString canPlayType(DOMString type);
+
+  // ready state
+  const unsigned short HAVE_NOTHING = 0;
+  const unsigned short HAVE_METADATA = 1;
+  const unsigned short HAVE_CURRENT_DATA = 2;
+  const unsigned short HAVE_FUTURE_DATA = 3;
+  const unsigned short HAVE_ENOUGH_DATA = 4;
+  readonly attribute unsigned short readyState;
+  readonly attribute boolean seeking;
+
+  // playback state
+  [SetterThrows]
+           attribute double currentTime;
+  // TODO: Bug 847375 - void fastSeek(double time);
+  readonly attribute unrestricted double duration;
+  // TODO: Bug 847376 - readonly attribute any startDate;
+  readonly attribute boolean paused;
+  [SetterThrows]
+           attribute double defaultPlaybackRate;
+  [SetterThrows]
+           attribute double playbackRate;
+  [Creator]
+  readonly attribute TimeRanges played;
+  [Creator]
+  readonly attribute TimeRanges seekable;
+  readonly attribute boolean ended;
+  [SetterThrows]
+           attribute boolean autoplay;
+  [SetterThrows]
+           attribute boolean loop;
+  [Throws]
+  void play();
+  [Throws]
+  void pause();
+
+  // TODO: Bug 847377 - mediaGroup and MediaController
+  // media controller
+  //         attribute DOMString mediaGroup;
+  //         attribute MediaController? controller;
+
+  // controls
+  [SetterThrows]
+           attribute boolean controls;
+  [SetterThrows]
+           attribute double volume;
+           attribute boolean muted;
+  [SetterThrows]
+           attribute boolean defaultMuted;
+
+  // TODO: Bug 847379
+  // tracks
+  //readonly attribute AudioTrackList audioTracks;
+  //readonly attribute VideoTrackList videoTracks;
+  //readonly attribute TextTrackList textTracks;
+  //TextTrack addTextTrack(DOMString kind, optional DOMString label, optional DOMString language);
+};
+
+// Mozilla extensions:
+partial interface HTMLMediaElement {
+  attribute MediaStream? mozSrcObject;
+  readonly attribute double initialTime;
+  attribute boolean mozPreservesPitch;
+  readonly attribute boolean mozAutoplayEnabled;
+
+  // Mozilla extension: stream capture
+  [Throws]
+  MediaStream mozCaptureStream();
+  [Throws]
+  MediaStream mozCaptureStreamUntilEnded();
+  readonly attribute boolean mozAudioCaptured;
+
+  // Mozilla extension: extra stream metadata information, used as part
+  // of MozAudioAvailable events and the mozWriteAudio() method.  The
+  // mozFrameBufferLength method allows for the size of the framebuffer
+  // used within MozAudioAvailable events to be changed.  The new size must
+  // be between 512 and 16384.  The default size, for a  media element with
+  // audio is (mozChannels * 1024).
+  [GetterThrows]
+  readonly attribute unsigned long mozChannels;
+  [GetterThrows]
+  readonly attribute unsigned long mozSampleRate;
+  [Throws]
+           attribute unsigned long mozFrameBufferLength;
+
+  // Mozilla extension: return embedded metadata from the stream as a
+  // JSObject with key:value pairs for each tag. This can be used by
+  // player interfaces to display the song title, artist, etc.
+  [Throws]
+  object? mozGetMetadata();
+
+  // Mozilla extension: load data from another media element. This is like
+  // load() but we don't run the resource selection algorithm; instead
+  // we just set our source to other's currentSrc. This is optimized
+  // so that this element will get access to all of other's cached/
+  // buffered data. In fact any future data downloaded by this element or
+  // other will be sharable by both elements.
+  [Throws]
+  void mozLoadFrom(HTMLMediaElement other);
+
+  // Mozilla extension: provides access to the fragment end time if
+  // the media element has a fragment URI for the currentSrc, otherwise
+  // it is equal to the media duration.
+  readonly attribute double mozFragmentEnd;
+
+  // Mozilla extension: an audio channel type for media elements.
+  // An exception is thrown if the app tries to change the audio channel type
+  // without the permission (manifest file for B2G apps).
+  // The supported values are:
+  // * normal (default value)
+  //   Automatically paused if "notification" or higher priority channel
+  //   is played
+  //   Use case: normal applications
+  // * content
+  //   Automatically paused if "notification" or higher priority channel
+  //   is played. Also paused if another app starts using "content"
+  //   channel. Using this channel never affects applications using
+  //   the "normal" channel.
+  //   Use case: video/audio players
+  // * notification
+  //   Automatically paused if "alarm" or higher priority channel is played.
+  //   Use case: New email, incoming SMS
+  // * alarm
+  //   Automatically paused if "telephony" or higher priority channel is
+  //   played.
+  //   User case: Alarm clock, calendar alarms
+  // * telephony
+  //   Automatically paused if "ringer" or higher priority
+  //   channel is played.
+  //   Use case: dialer, voip
+  // * ringer
+  //   Automatically paused if "publicnotification" or higher priority
+  //   channel is played.
+  //   Use case: dialer, voip
+  // * publicnotification
+  //   Always plays in speaker, even when headphones are plugged in.
+  //   Use case: Camera shutter sound.
+  [SetterThrows]
+  attribute DOMString mozAudioChannelType;
+
+  // In addition the media element has this new events:
+  // * onmozinterruptbegin - called when the media element is interrupted
+  //   because of the audiochannel manager.
+  // * onmozinterruptend - called when the interruption is concluded
+};

dom/webidl/WebIDL.mk

@@ -96,6 +96,7 @@ webidl_files = \
   HTMLLIElement.webidl \
   HTMLLinkElement.webidl \
   HTMLMapElement.webidl \
+  HTMLMediaElement.webidl \
   HTMLMenuElement.webidl \
   HTMLMenuItemElement.webidl \
   HTMLMetaElement.webidl \