Attachment #469714 for bug #584615

Attachment #469714: Rolled up and rebased patch for bug #584615

View | Details | Raw Unified | Return to bug 584615
Collapse All | Expand All

(-)a/content/html/content/public/nsHTMLMediaElement.h (-4 / +2 lines)

Line	Link Here

Lines 184-193 public:	Link Here

184

  gfxASurface* GetPrintSurface() { return mPrintSurface; }

184

  gfxASurface* GetPrintSurface() { return mPrintSurface; }

185

186

  // Dispatch events

186

  // Dispatch events

187

  nsresult DispatchSimpleEvent(const nsAString& aName);

187

  nsresult DispatchEvent(const nsAString& aName);

188

  nsresult DispatchProgressEvent(const nsAString& aName);

188

  nsresult DispatchAsyncEvent(const nsAString& aName);

189

  nsresult DispatchAsyncSimpleEvent(const nsAString& aName);

190

  nsresult DispatchAsyncProgressEvent(const nsAString& aName);

191

  nsresult DispatchAudioAvailableEvent(float* aFrameBuffer,

189

  nsresult DispatchAudioAvailableEvent(float* aFrameBuffer,

192

                                       PRUint32 aFrameBufferLength,

190

                                       PRUint32 aFrameBufferLength,

193

                                       PRUint64 aTime);

191

                                       PRUint64 aTime);






#include "nsEventDispatcher.h"
#include "nsIDOMDocumentEvent.h"
#include "nsIDOMProgressEvent.h"
#include "nsMediaError.h"
#include "nsICategoryManager.h"
#include "nsCharSeparatedTokenizer.h"

{
private:
  nsString mName;
  PRPackedBool mProgress;

public:
  nsAsyncEventRunner(const nsAString& aName, nsHTMLMediaElement* aElement) :
    nsMediaEvent(aElement), mName(aName)
  {
  }


    if (IsCancelled())
      return NS_OK;

    return mElement->DispatchEvent(mName);
      mElement->DispatchProgressEvent(mName) :
      mElement->DispatchSimpleEvent(mName);
  }
};


      mNetworkState == nsIDOMHTMLMediaElement::NETWORK_IDLE)
  {
    mError = new nsMediaError(nsIDOMMediaError::MEDIA_ERR_ABORTED);
    DispatchEvent(NS_LITERAL_STRING("abort"));
  }

  mError = nsnull;

      // will now be reported as 0. The playback position was non-zero when
      // we destroyed the decoder, so fire a timeupdate event so that the
      // change will be reflected in the controls.
      DispatchAsyncEvent(NS_LITERAL_STRING("timeupdate"));
    }
    DispatchEvent(NS_LITERAL_STRING("emptied"));
  }

  // We may have changed mPaused, mAutoplaying, mNetworkState and other


  mError = new nsMediaError(nsIDOMMediaError::MEDIA_ERR_SRC_NOT_SUPPORTED);
  mNetworkState = nsIDOMHTMLMediaElement::NETWORK_NO_SOURCE;
  DispatchAsyncEvent(NS_LITERAL_STRING("error"));
  // This clears mDelayingLoadEvent, so AddRemoveSelfReference will be called
  ChangeDelayLoadStatus(PR_FALSE);
}

  mNetworkState = nsIDOMHTMLMediaElement::NETWORK_LOADING;
  // Load event was delayed, and still is, so no need to call
  // AddRemoveSelfReference, since it must still be held
  DispatchAsyncEvent(NS_LITERAL_STRING("loadstart"));

  nsAutoString src;
  nsCOMPtr<nsIURI> uri;

  mLoadIsSuspended = PR_TRUE;
  mPreloadURI = aURI;
  mNetworkState = nsIDOMHTMLMediaElement::NETWORK_IDLE;
  DispatchAsyncEvent(NS_LITERAL_STRING("suspend"));
  ChangeDelayLoadStatus(PR_FALSE);
}


    return rv;
  }

  DispatchAsyncEvent(NS_LITERAL_STRING("loadstart"));

  return NS_OK;
}

    return rv;
  }

  DispatchAsyncEvent(NS_LITERAL_STRING("loadstart"));

  return NS_OK;
}

  AddRemoveSelfReference();

  if (!oldPaused) {
    DispatchAsyncEvent(NS_LITERAL_STRING("timeupdate"));
    DispatchAsyncEvent(NS_LITERAL_STRING("pause"));
  }

  return NS_OK;

    mAudioStream->SetVolume(mVolume);
  }

  DispatchAsyncEvent(NS_LITERAL_STRING("volumechange"));

  return NS_OK;
}

    mAudioStream->SetVolume(mMuted ? 0.0 : mVolume);
  }

  DispatchAsyncEvent(NS_LITERAL_STRING("volumechange"));

  return NS_OK;
}

  // seek to the effective start.
  // TODO: The playback rate must be set to the default playback rate.
  if (mPaused) {
    DispatchAsyncEvent(NS_LITERAL_STRING("play"));
    switch (mReadyState) {
    case nsIDOMHTMLMediaElement::HAVE_METADATA:
    case nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA:
      DispatchAsyncEvent(NS_LITERAL_STRING("waiting"));
      break;
    case nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA:
    case nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA:
      DispatchAsyncEvent(NS_LITERAL_STRING("playing"));
      break;
    }
  }

  mChannels = aChannels;
  mRate = aRate;
  ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_METADATA);
  DispatchAsyncEvent(NS_LITERAL_STRING("durationchange"));
  DispatchAsyncEvent(NS_LITERAL_STRING("loadedmetadata"));
}

void nsHTMLMediaElement::FirstFrameLoaded(PRBool aResourceFullyLoaded)

  AddRemoveSelfReference();
  ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA);
  // The download has stopped
  DispatchAsyncEvent(NS_LITERAL_STRING("suspend"));
}

void nsHTMLMediaElement::NetworkError()
{
  mError = new nsMediaError(nsIDOMMediaError::MEDIA_ERR_NETWORK);
  mBegun = PR_FALSE;
  DispatchAsyncEvent(NS_LITERAL_STRING("error"));
  mNetworkState = nsIDOMHTMLMediaElement::NETWORK_EMPTY;
  AddRemoveSelfReference();
  DispatchAsyncEvent(NS_LITERAL_STRING("emptied"));
  ChangeDelayLoadStatus(PR_FALSE);
}


{
  mError = new nsMediaError(nsIDOMMediaError::MEDIA_ERR_DECODE);
  mBegun = PR_FALSE;
  DispatchAsyncEvent(NS_LITERAL_STRING("error"));
  mNetworkState = nsIDOMHTMLMediaElement::NETWORK_EMPTY;
  AddRemoveSelfReference();
  DispatchAsyncEvent(NS_LITERAL_STRING("emptied"));
  ChangeDelayLoadStatus(PR_FALSE);
}


  // We changed the state of IsPlaybackEnded which can affect AddRemoveSelfReference
  AddRemoveSelfReference();

  DispatchAsyncEvent(NS_LITERAL_STRING("ended"));
}

void nsHTMLMediaElement::SeekStarted()
{
  DispatchAsyncEvent(NS_LITERAL_STRING("seeking"));
}

void nsHTMLMediaElement::SeekCompleted()
{
  mPlayingBeforeSeek = PR_FALSE;
  SetPlayedOrSeeked(PR_TRUE);
  DispatchAsyncEvent(NS_LITERAL_STRING("seeked"));
  // We changed whether we're seeking so we need to AddRemoveSelfReference
  AddRemoveSelfReference();
}

  if (mBegun) {
    mNetworkState = nsIDOMHTMLMediaElement::NETWORK_IDLE;
    AddRemoveSelfReference();
    DispatchAsyncEvent(NS_LITERAL_STRING("suspend"));
  }
}


void nsHTMLMediaElement::DownloadStalled()
{
  if (mNetworkState == nsIDOMHTMLMediaElement::NETWORK_LOADING) {
    DispatchAsyncEvent(NS_LITERAL_STRING("stalled"));
  }
}


  if (aNextFrame != NEXT_FRAME_AVAILABLE) {
    ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA);
    if (!mWaitingFired && aNextFrame == NEXT_FRAME_UNAVAILABLE_BUFFERING) {
      DispatchAsyncEvent(NS_LITERAL_STRING("waiting"));
      mWaitingFired = PR_TRUE;
    }
    return;

  // Handle raising of "waiting" event during seek (see 4.8.10.9)
  if (mPlayingBeforeSeek &&
      oldState < nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA) {
    DispatchAsyncEvent(NS_LITERAL_STRING("waiting"));
  }

  if (oldState < nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA &&
      mReadyState >= nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA &&
      !mLoadedFirstFrame)
  {
    DispatchAsyncEvent(NS_LITERAL_STRING("loadeddata"));
    mLoadedFirstFrame = PR_TRUE;
  }



  if (oldState < nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA &&
      mReadyState >= nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA) {
    DispatchAsyncEvent(NS_LITERAL_STRING("canplay"));
  }

  if (mReadyState == nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA) {

  if (oldState < nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA &&
      mReadyState >= nsIDOMHTMLMediaElement::HAVE_FUTURE_DATA &&
      IsPotentiallyPlaying()) {
    DispatchAsyncEvent(NS_LITERAL_STRING("playing"));
  }

  if (oldState < nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA &&
      mReadyState >= nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA) {
    DispatchAsyncEvent(NS_LITERAL_STRING("canplaythrough"));
  }
}


      SetPlayedOrSeeked(PR_TRUE);
      mDecoder->Play();
    }
    DispatchAsyncEvent(NS_LITERAL_STRING("play"));
  }
}


  return target->DispatchEvent(event, &dummy);
}

nsresult nsHTMLMediaElement::DispatchEvent(const nsAString& aName)
{
  LOG_EVENT(PR_LOG_DEBUG, ("%p Dispatching event %s", this,
                          NS_ConvertUTF16toUTF8(aName).get()));

  return nsContentUtils::DispatchTrustedEvent(GetOwnerDoc(),

                                              PR_TRUE);
}

nsresult nsHTMLMediaElement::DispatchAsyncEvent(const nsAString& aName)
{
  LOG_EVENT(PR_LOG_DEBUG, ("%p Queuing event %s", this,
                           NS_ConvertUTF16toUTF8(aName).get()));

  nsCOMPtr<nsIRunnable> event = new nsAsyncEventRunner(aName, this);
  NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);
  return NS_OK;
}

nsresult nsHTMLMediaElement::DispatchAsyncProgressEvent(const nsAString& aName)
{
  LOG_EVENT(PR_LOG_DEBUG, ("%p Queuing progress event %s", this, NS_ConvertUTF16toUTF8(aName).get()));

  nsCOMPtr<nsIRunnable> event = new nsAsyncEventRunner(aName, this, PR_TRUE);
  NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);
  return NS_OK;
}

nsresult nsHTMLMediaElement::DispatchProgressEvent(const nsAString& aName)
{
  nsCOMPtr<nsIDOMDocumentEvent> docEvent(do_QueryInterface(GetOwnerDoc()));
  nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(static_cast<nsIContent*>(this)));
  NS_ENSURE_TRUE(docEvent && target, NS_ERROR_INVALID_ARG);

  nsCOMPtr<nsIDOMEvent> event;
  nsresult rv = docEvent->CreateEvent(NS_LITERAL_STRING("ProgressEvent"), getter_AddRefs(event));
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIDOMProgressEvent> progressEvent(do_QueryInterface(event));
  NS_ENSURE_TRUE(progressEvent, NS_ERROR_FAILURE);

  PRInt64 totalBytes = 0;
  PRUint64 downloadPosition = 0;
  if (mDecoder) {
    nsMediaDecoder::Statistics stats = mDecoder->GetStatistics();
    totalBytes = stats.mTotalBytes;
    downloadPosition = stats.mDownloadPosition;
  }
  rv = progressEvent->InitProgressEvent(aName, PR_TRUE, PR_TRUE,
    totalBytes >= 0, downloadPosition, totalBytes);
  NS_ENSURE_SUCCESS(rv, rv);

  LOG_EVENT(PR_LOG_DEBUG, ("%p Dispatching progress event %s", this,
                          NS_ConvertUTF16toUTF8(aName).get()));

  PRBool dummy;
  return target->DispatchEvent(event, &dummy);
}

nsresult nsHTMLMediaElement::DoneAddingChildren(PRBool aHaveNotified)
{
  if (!mIsDoneAddingChildren) {

  nsTimeRanges* ranges = new nsTimeRanges();
  NS_ADDREF(*aBuffered = ranges);
  if (mReadyState >= nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA && mDecoder) {
    // If GetBuffered fails we ignore the error result and just return the
    // time ranges we found up till the error.
    mDecoder->GetBuffered(ranges);
  }
  return NS_OK;
}





  else if (mElement) {
    // Resource was loaded during metadata loading, when progress
    // events are being ignored. Fire the final progress event.
    mElement->DispatchAsyncEvent(NS_LITERAL_STRING("progress"));
  }

  // Only inform the element of FirstFrameLoaded if not doing a load() in order


  // Ensure the final progress event gets fired
  if (mElement) {
    mElement->DispatchAsyncEvent(NS_LITERAL_STRING("progress"));
    mElement->ResourceLoaded();
  }
}

  Invalidate();

  if (mElement && lastTime != mCurrentTime) {
    mElement->DispatchEvent(NS_LITERAL_STRING("timeupdate"));
  }
}



  if (mElement && oldDuration != mDuration) {
    LOG(PR_LOG_DEBUG, ("%p duration changed to %lldms", this, mDuration));
    mElement->DispatchEvent(NS_LITERAL_STRING("durationchange"));
  }
}


(-)a/content/media/nsMediaDecoder.cpp (-1 / +1 lines)

Line	Link Here

Lines 200-206 void nsMediaDecoder::Progress(PRBool aTimer)	Link Here

200

       now - mProgressTime >= TimeDuration::FromMilliseconds(PROGRESS_MS)) &&

200

       now - mProgressTime >= TimeDuration::FromMilliseconds(PROGRESS_MS)) &&

201

      !mDataTime.IsNull() &&

201

      !mDataTime.IsNull() &&

202

      now - mDataTime <= TimeDuration::FromMilliseconds(PROGRESS_MS)) {

202

      now - mDataTime <= TimeDuration::FromMilliseconds(PROGRESS_MS)) {

203

    mElement->DispatchAsyncProgressEvent(NS_LITERAL_STRING("progress"));

203

    mElement->DispatchAsyncEvent(NS_LITERAL_STRING("progress"));

204

    mProgressTime = now;

204

    mProgressTime = now;

205

206





      // We need more data if we've not encountered a page we've seen before,
      // or we've read to the end of file.
      if (mustBackOff || readHead == aEndOffset) {
        if (endTime != -1 || readStartOffset == 0) {
          // We have encountered a page before, or we're at the end of file.
          break;
        }

nsresult nsOggReader::GetBuffered(nsTimeRanges* aBuffered, PRInt64 aStartTime)
{
  NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");

  // HasAudio and HasVideo are not used here as they take a lock and cause
  // a deadlock. Accessing mInfo doesn't require a lock - it doesn't change
  // after metadata is read and GetBuffered isn't called before metadata is
  // read.
  if (!mInfo.mHasVideo && !mInfo.mHasAudio) {
    // No need to search through the file if there are no audio or video tracks
    return NS_OK;
  }

  nsMediaStream* stream = mDecoder->GetCurrentStream();

  // Traverse across the buffered byte ranges, determining the time ranges





function do_progress(e) {
  var v = e.target;
  ok(!v._finished, "Check no progress events after completed for " + v._name);
  ok(e.lengthComputable, "Check progress lengthComputable for " + v._name);
  ok(e.loaded >= v._last_progress_total, "Check progress increasing: " + e.loaded + " for " + v._name);
  v._last_progress_total = e.loaded;
  ok(e.loaded <= e.total, "Check progress in bounds: " + e.loaded + " for " + v._name);
  is(e.total, v._size, "Check progress total for " + v._name);
}

function do_ended(e) {

  v.src = test.name;
  v.autoplay = true;
  v._name = test.name;
  v._size = test.size;
  v._finished = false;
  v._last_progress_total = 0;
  v.addEventListener("ended", do_ended, false);
  v.addEventListener("progress", do_progress, false);
  document.body.appendChild(v);

(-)a/content/media/wave/nsWaveDecoder.cpp (-2 / +2 lines)

Line	Link Here

Lines 1466-1472 nsWaveDecoder::ResourceLoaded()	Link Here

1466

1467

  if (mElement) {

1467

  if (mElement) {

1468

    // Ensure the final progress event gets fired

1468

    // Ensure the final progress event gets fired

1469

    mElement->DispatchAsyncProgressEvent(NS_LITERAL_STRING("progress"));

1469

    mElement->DispatchAsyncEvent(NS_LITERAL_STRING("progress"));

1470

    mElement->ResourceLoaded();

1470

    mElement->ResourceLoaded();

1471

1472

Lines 1673-1679 nsWaveDecoder::PlaybackPositionChanged()	Link Here

1673

1674

  if (mElement && lastTime != mCurrentTime) {

1674

  if (mElement && lastTime != mCurrentTime) {

1675

    UpdateReadyStateForData();

1675

    UpdateReadyStateForData();

1676

    mElement->DispatchSimpleEvent(NS_LITERAL_STRING("timeupdate"));

1676

    mElement->DispatchEvent(NS_LITERAL_STRING("timeupdate"));

1677

1678

1679

Return to bug 584615