Backed out 5 changesets (bug 882543) for crashtest orange on a CLOSED TREE.

Backed out changeset b36516aab389 (bug 882543)
Backed out changeset 07550003a24a (bug 882543)
Backed out changeset f4045c40afb4 (bug 882543)
Backed out changeset 1b87e0bd2858 (bug 882543)
Backed out changeset 8d76a3440800 (bug 882543)

content/media/MediaStreamGraph.cpp

@@ -4,7 +4,6 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "MediaStreamGraphImpl.h"
-#include "mozilla/LinkedList.h"
 
 #include "AudioSegment.h"
 #include "VideoSegment.h"
@@ -24,7 +23,6 @@
 #include "AudioNodeStream.h"
 #include <algorithm>
 #include "DOMMediaStream.h"
-#include "GeckoProfiler.h"
 
 using namespace mozilla::layers;
 using namespace mozilla::dom;
@@ -315,30 +313,20 @@ MediaStreamGraphImpl::GetAudioPosition(MediaStream* aStream)
 void
 MediaStreamGraphImpl::UpdateCurrentTime()
 {
-  GraphTime prevCurrentTime, nextCurrentTime;
-  if (mRealtime) {
-    TimeStamp now = TimeStamp::Now();
-    prevCurrentTime = mCurrentTime;
-    nextCurrentTime =
-      SecondsToMediaTime((now - mCurrentTimeStamp).ToSeconds()) + mCurrentTime;
-
-    mCurrentTimeStamp = now;
-    LOG(PR_LOG_DEBUG+1, ("Updating current time to %f (real %f, mStateComputedTime %f)",
-          MediaTimeToSeconds(nextCurrentTime),
-          (now - mInitialTimeStamp).ToSeconds(),
-          MediaTimeToSeconds(mStateComputedTime)));
-  } else {
-    prevCurrentTime = mCurrentTime;
-    nextCurrentTime = mCurrentTime + MEDIA_GRAPH_TARGET_PERIOD_MS;
-    LOG(PR_LOG_DEBUG+1, ("Updating offline current time to %f (mStateComputedTime %f)",
-          MediaTimeToSeconds(nextCurrentTime),
-          MediaTimeToSeconds(mStateComputedTime)));
-  }
-
+  GraphTime prevCurrentTime = mCurrentTime;
+  TimeStamp now = TimeStamp::Now();
+  GraphTime nextCurrentTime =
+    SecondsToMediaTime((now - mCurrentTimeStamp).ToSeconds()) + mCurrentTime;
   if (mStateComputedTime < nextCurrentTime) {
     LOG(PR_LOG_WARNING, ("Media graph global underrun detected"));
     nextCurrentTime = mStateComputedTime;
   }
+  mCurrentTimeStamp = now;
+
+  LOG(PR_LOG_DEBUG+1, ("Updating current time to %f (real %f, mStateComputedTime %f)",
+                       MediaTimeToSeconds(nextCurrentTime),
+                       (now - mInitialTimeStamp).ToSeconds(),
+                       MediaTimeToSeconds(mStateComputedTime)));
 
   if (prevCurrentTime >= nextCurrentTime) {
     NS_ASSERTION(prevCurrentTime == nextCurrentTime, "Time can't go backwards!");
@@ -466,22 +454,22 @@ MediaStreamGraphImpl::MarkConsumed(MediaStream* aStream)
 }
 
 void
-MediaStreamGraphImpl::UpdateStreamOrderForStream(mozilla::LinkedList<MediaStream>* aStack,
+MediaStreamGraphImpl::UpdateStreamOrderForStream(nsTArray<MediaStream*>* aStack,
                                                  already_AddRefed<MediaStream> aStream)
 {
   nsRefPtr<MediaStream> stream = aStream;
   NS_ASSERTION(!stream->mHasBeenOrdered, "stream should not have already been ordered");
   if (stream->mIsOnOrderingStack) {
-    MediaStream* iter = aStack->getLast();
-    do {
-      iter->AsProcessedStream()->mInCycle = true;
-      iter = iter->getPrevious();
-    } while (iter != stream);
+    for (int32_t i = aStack->Length() - 1; ; --i) {
+      aStack->ElementAt(i)->AsProcessedStream()->mInCycle = true;
+      if (aStack->ElementAt(i) == stream)
+        break;
+    }
     return;
   }
   ProcessedMediaStream* ps = stream->AsProcessedStream();
   if (ps) {
-    aStack->insertBack(stream);
+    aStack->AppendElement(stream);
     stream->mIsOnOrderingStack = true;
     for (uint32_t i = 0; i < ps->mInputs.Length(); ++i) {
       MediaStream* source = ps->mInputs[i]->mSource;
@@ -490,7 +478,7 @@ MediaStreamGraphImpl::UpdateStreamOrderForStream(mozilla::LinkedList<MediaStream
         UpdateStreamOrderForStream(aStack, s.forget());
       }
     }
-    aStack->popLast();
+    aStack->RemoveElementAt(aStack->Length() - 1);
     stream->mIsOnOrderingStack = false;
   }
 
@@ -501,10 +489,10 @@ MediaStreamGraphImpl::UpdateStreamOrderForStream(mozilla::LinkedList<MediaStream
 void
 MediaStreamGraphImpl::UpdateStreamOrder()
 {
-  mOldStreams.SwapElements(mStreams);
-  mStreams.ClearAndRetainStorage();
-  for (uint32_t i = 0; i < mOldStreams.Length(); ++i) {
-    MediaStream* stream = mOldStreams[i];
+  nsTArray<nsRefPtr<MediaStream> > oldStreams;
+  oldStreams.SwapElements(mStreams);
+  for (uint32_t i = 0; i < oldStreams.Length(); ++i) {
+    MediaStream* stream = oldStreams[i];
     stream->mHasBeenOrdered = false;
     stream->mIsConsumed = false;
     stream->mIsOnOrderingStack = false;
@@ -515,9 +503,9 @@ MediaStreamGraphImpl::UpdateStreamOrder()
     }
   }
 
-  mozilla::LinkedList<MediaStream> stack;
-  for (uint32_t i = 0; i < mOldStreams.Length(); ++i) {
-    nsRefPtr<MediaStream>& s = mOldStreams[i];
+  nsAutoTArray<MediaStream*,10> stack;
+  for (uint32_t i = 0; i < oldStreams.Length(); ++i) {
+    nsRefPtr<MediaStream>& s = oldStreams[i];
     if (!s->mAudioOutputs.IsEmpty() || !s->mVideoOutputs.IsEmpty()) {
       MarkConsumed(s);
     }
@@ -900,47 +888,28 @@ MediaStreamGraphImpl::PlayVideo(MediaStream* aStream)
   }
 }
 
-bool
-MediaStreamGraphImpl::ShouldUpdateMainThread()
-{
-  if (mRealtime) {
-    return true;
-  }
-
-  TimeStamp now = TimeStamp::Now();
-  if ((now - mLastMainThreadUpdate).ToMilliseconds() > MEDIA_GRAPH_TARGET_PERIOD_MS) {
-    mLastMainThreadUpdate = now;
-    return true;
-  }
-  return false;
-}
-
 void
 MediaStreamGraphImpl::PrepareUpdatesToMainThreadState(bool aFinalUpdate)
 {
   mMonitor.AssertCurrentThreadOwns();
 
-  // We don't want to update the main thread about timing update when we are not
-  // running in realtime.
-  if (ShouldUpdateMainThread()) {
-    mStreamUpdates.SetCapacity(mStreamUpdates.Length() + mStreams.Length());
-    for (uint32_t i = 0; i < mStreams.Length(); ++i) {
-      MediaStream* stream = mStreams[i];
-      if (!stream->MainThreadNeedsUpdates()) {
-        continue;
-      }
-      StreamUpdate* update = mStreamUpdates.AppendElement();
-      update->mGraphUpdateIndex = stream->mGraphUpdateIndices.GetAt(mCurrentTime);
-      update->mStream = stream;
-      update->mNextMainThreadCurrentTime =
-        GraphTimeToStreamTime(stream, mCurrentTime);
-      update->mNextMainThreadFinished =
-        stream->mFinished &&
-        StreamTimeToGraphTime(stream, stream->GetBufferEnd()) <= mCurrentTime;
-    }
-    if (!mPendingUpdateRunnables.IsEmpty()) {
-      mUpdateRunnables.MoveElementsFrom(mPendingUpdateRunnables);
+  mStreamUpdates.SetCapacity(mStreamUpdates.Length() + mStreams.Length());
+  for (uint32_t i = 0; i < mStreams.Length(); ++i) {
+    MediaStream* stream = mStreams[i];
+    if (!stream->MainThreadNeedsUpdates()) {
+      continue;
     }
+    StreamUpdate* update = mStreamUpdates.AppendElement();
+    update->mGraphUpdateIndex = stream->mGraphUpdateIndices.GetAt(mCurrentTime);
+    update->mStream = stream;
+    update->mNextMainThreadCurrentTime =
+      GraphTimeToStreamTime(stream, mCurrentTime);
+    update->mNextMainThreadFinished =
+      stream->mFinished &&
+      StreamTimeToGraphTime(stream, stream->GetBufferEnd()) <= mCurrentTime;
+  }
+  if (!mPendingUpdateRunnables.IsEmpty()) {
+    mUpdateRunnables.MoveElementsFrom(mPendingUpdateRunnables);
   }
 
   // Don't send the message to the main thread if it's not going to have
@@ -1203,7 +1172,6 @@ MediaStreamGraphImpl::RunThread()
   if (!mRealtime) {
     mNonRealtimeIsRunning = false;
   }
-  profiler_unregister_thread();
 }
 
 void
@@ -1249,23 +1217,6 @@ MediaStreamGraphImpl::ForceShutDown()
 
 namespace {
 
-class MediaStreamGraphInitThreadRunnable : public nsRunnable {
-public:
-  explicit MediaStreamGraphInitThreadRunnable(MediaStreamGraphImpl* aGraph)
-    : mGraph(aGraph)
-  {
-  }
-  NS_IMETHOD Run()
-  {
-    char aLocal;
-    profiler_register_thread("MediaStreamGraph", &aLocal);
-    mGraph->RunThread();
-    return NS_OK;
-  }
-private:
-  MediaStreamGraphImpl* mGraph;
-};
-
 class MediaStreamGraphThreadRunnable : public nsRunnable {
 public:
   explicit MediaStreamGraphThreadRunnable(MediaStreamGraphImpl* aGraph)
@@ -1405,7 +1356,7 @@ MediaStreamGraphImpl::RunInStableState()
       // Start the thread now. We couldn't start it earlier because
       // the graph might exit immediately on finding it has no streams. The
       // first message for a new graph must create a stream.
-      nsCOMPtr<nsIRunnable> event = new MediaStreamGraphInitThreadRunnable(this);
+      nsCOMPtr<nsIRunnable> event = new MediaStreamGraphThreadRunnable(this);
       NS_NewNamedThread("MediaStreamGrph", getter_AddRefs(mThread), event);
     }
 
@@ -2217,7 +2168,7 @@ MediaStreamGraphImpl::MediaStreamGraphImpl(bool aRealtime)
   }
 #endif
 
-  mCurrentTimeStamp = mInitialTimeStamp = mLastMainThreadUpdate = TimeStamp::Now();
+  mCurrentTimeStamp = mInitialTimeStamp = TimeStamp::Now();
 }
 
 NS_IMPL_ISUPPORTS1(MediaStreamGraphShutdownObserver, nsIObserver)

content/media/MediaStreamGraph.h

@@ -7,7 +7,6 @@
 #define MOZILLA_MEDIASTREAMGRAPH_H_
 
 #include "mozilla/Mutex.h"
-#include "mozilla/LinkedList.h"
 #include "AudioStream.h"
 #include "nsTArray.h"
 #include "nsIRunnable.h"
@@ -258,7 +257,7 @@ struct AudioChunk;
  * for those objects in arbitrary order and the MediaStreamGraph has to be able
  * to handle this.
  */
-class MediaStream : public mozilla::LinkedListElement<MediaStream> {
+class MediaStream {
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaStream)
 

content/media/MediaStreamGraphImpl.h

@@ -15,9 +15,6 @@
 
 namespace mozilla {
 
-template <typename T>
-class LinkedList;
-
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* gMediaStreamGraphLog;
 #define LOG(type, msg) PR_LOG(gMediaStreamGraphLog, type, msg)
@@ -193,12 +190,6 @@ public:
    * mMonitor must be held.
    */
   void PrepareUpdatesToMainThreadState(bool aFinalUpdate);
-  /**
-   * If we are rendering in non-realtime mode, we don't want to send messages to
-   * the main thread at each iteration for performance reasons. We instead
-   * notify the main thread at the same rate
-   */
-  bool ShouldUpdateMainThread();
   // The following methods are the various stages of RunThread processing.
   /**
    * Compute a new current time for the graph and advance all on-graph-thread
@@ -224,7 +215,7 @@ public:
    * If aStream hasn't already been ordered, push it onto aStack and order
    * its children.
    */
-  void UpdateStreamOrderForStream(mozilla::LinkedList<MediaStream>* aStack,
+  void UpdateStreamOrderForStream(nsTArray<MediaStream*>* aStack,
                                   already_AddRefed<MediaStream> aStream);
   /**
    * Mark aStream and all its inputs (recursively) as consumed.
@@ -379,11 +370,6 @@ public:
   // is not running and this state can be used from the main thread.
 
   nsTArray<nsRefPtr<MediaStream> > mStreams;
-  /**
-   * mOldStreams is used as temporary storage for streams when computing the
-   * order in which we compute them.
-   */
-  nsTArray<nsRefPtr<MediaStream> > mOldStreams;
   /**
    * The current graph time for the current iteration of the RunThread control
    * loop.
@@ -403,10 +389,6 @@ public:
    * The real timestamp of the latest run of UpdateCurrentTime.
    */
   TimeStamp mCurrentTimeStamp;
-  /**
-   * Date of the last time we updated the main thread with the graph state.
-   */
-  TimeStamp mLastMainThreadUpdate;
   /**
    * Which update batch we are currently processing.
    */

xpcom/glue/nsTArray.h

@@ -1042,20 +1042,6 @@ public:
   //
   // Mutation methods
   //
-  // This method call the destructor on each element of the array, empties it,
-  // but does not shrink the array's capacity.
-  //
-  // Make sure to call Compact() if needed to avoid keeping a huge array
-  // around.
-  void ClearAndRetainStorage() {
-    if (base_type::mHdr == EmptyHdr()) {
-      return;
-    }
-
-    DestructRange(0, Length());
-    base_type::mHdr->mLength = 0;
-  }
-
 
   // This method replaces a range of elements in this array.
   // @param start     The starting index of the elements to replace.