--- a/browser/base/content/content.js
+++ b/browser/base/content/content.js
@@ -11,28 +11,16 @@ Cu.import("resource://gre/modules/XPCOMU
 
 XPCOMUtils.defineLazyModuleGetter(this,
   "LoginManagerContent", "resource://gre/modules/LoginManagerContent.jsm");
 XPCOMUtils.defineLazyModuleGetter(this,
   "InsecurePasswordUtils", "resource://gre/modules/InsecurePasswordUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "PrivateBrowsingUtils",
   "resource://gre/modules/PrivateBrowsingUtils.jsm");
 
-// Bug 671101 - directly using webNavigation in this context
-// causes docshells to leak
-this.__defineGetter__("webNavigation", function () {
-  return docShell.QueryInterface(Ci.nsIWebNavigation);
-});
-
-addMessageListener("WebNavigation:LoadURI", function (message) {
-  let flags = message.json.flags || webNavigation.LOAD_FLAGS_NONE;
-
-  webNavigation.loadURI(message.json.uri, flags, null, null, null);
-});
-
 addMessageListener("Browser:HideSessionRestoreButton", function (message) {
   // Hide session restore button on about:home
   let doc = content.document;
   let container;
   if (doc.documentURI.toLowerCase() == "about:home" &&
       (container = doc.getElementById("sessionRestoreContainer"))){
     container.hidden = true;
   }

--- a/caps/idl/nsIPrincipal.idl
+++ b/caps/idl/nsIPrincipal.idl
@@ -3,17 +3,16 @@
  * 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/. */
 
 /* Defines the abstract interface for a principal. */
 
 #include "nsISerializable.idl"
 
 %{C++
-struct JSContext;
 struct JSPrincipals;
 #include "nsCOMPtr.h"
 #include "nsTArray.h"
 %}
 
 interface nsIURI;
 interface nsIContentSecurityPolicy;
 

--- a/caps/include/nsScriptSecurityManager.h
+++ b/caps/include/nsScriptSecurityManager.h
@@ -13,23 +13,20 @@
 #include "nsInterfaceHashtable.h"
 #include "nsHashtable.h"
 #include "nsCOMPtr.h"
 #include "nsIChannelEventSink.h"
 #include "nsIObserver.h"
 #include "pldhash.h"
 #include "plstr.h"
 #include "nsIScriptExternalNameSet.h"
+#include "js/TypeDecls.h"
 
 #include <stdint.h>
 
-namespace JS {
-template <typename T> class Handle;
-template <typename T> class MutableHandle;
-}
 class nsIDocShell;
 class nsString;
 class nsIClassInfo;
 class nsIIOService;
 class nsIStringBundle;
 class nsSystemPrincipal;
 struct ClassPolicy;
 class ClassInfoData;

--- a/content/base/public/nsContentUtils.h
+++ b/content/base/public/nsContentUtils.h
@@ -13,16 +13,17 @@
 #if defined(XP_WIN) || defined(XP_OS2)
 #include <float.h>
 #endif
 
 #if defined(SOLARIS)
 #include <ieeefp.h>
 #endif
 
+#include "js/TypeDecls.h"
 #include "js/RootingAPI.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/GuardObjects.h"
 #include "mozilla/TimeStamp.h"
 #include "nsContentListDeclarations.h"
 #include "nsMathUtils.h"
 
 class imgICache;
@@ -87,31 +88,26 @@ class nsNodeInfoManager;
 class nsPIDOMWindow;
 class nsPresContext;
 class nsScriptObjectTracer;
 class nsStringHashKey;
 class nsTextFragment;
 class nsViewportInfo;
 class nsWrapperCache;
 
-struct JSContext;
 struct JSPropertyDescriptor;
 struct JSRuntime;
 struct nsIntMargin;
 
 template<class E> class nsCOMArray;
 template<class E> class nsTArray;
 template<class K, class V> class nsDataHashtable;
 template<class K, class V> class nsRefPtrHashtable;
 template<class T> class nsReadingIterator;
 
-namespace JS {
-class Value;
-} // namespace JS
-
 namespace mozilla {
 class ErrorResult;
 class Selection;
 
 namespace dom {
 class DocumentFragment;
 class Element;
 class EventTarget;

--- a/content/base/public/nsINode.h
+++ b/content/base/public/nsINode.h
@@ -14,16 +14,17 @@
 #include "nsIVariant.h"             // for use in GetUserData()
 #include "nsNodeInfoManager.h"      // for use in NodePrincipal()
 #include "nsPropertyTable.h"        // for typedefs
 #include "nsTObserverArray.h"       // for member
 #include "nsWindowMemoryReporter.h" // for NS_DECL_SIZEOF_EXCLUDING_THIS
 #include "mozilla/ErrorResult.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/dom/EventTarget.h" // for base class
+#include "js/TypeDecls.h"     // for Handle, Value, JSObject, JSContext
 
 // Including 'windows.h' will #define GetClassInfo to something else.
 #ifdef XP_WIN
 #ifdef GetClassInfo
 #undef GetClassInfo
 #endif
 #endif
 
@@ -62,21 +63,16 @@ inline bool IsSpaceCharacter(char aChar)
 }
 class Element;
 class EventHandlerNonNull;
 class OnErrorEventHandlerNonNull;
 template<typename T> class Optional;
 } // namespace dom
 } // namespace mozilla
 
-namespace JS {
-class Value;
-template<typename T> class Handle;
-}
-
 #define NODE_FLAG_BIT(n_) (1U << (WRAPPER_CACHE_FLAGS_BITS_USED + (n_)))
 
 enum {
   // This bit will be set if the node has a listener manager.
   NODE_HAS_LISTENERMANAGER =              NODE_FLAG_BIT(0),
 
   // Whether this node has had any properties set on it
   NODE_HAS_PROPERTIES =                   NODE_FLAG_BIT(1),

--- a/content/base/src/nsFrameMessageManager.h
+++ b/content/base/src/nsFrameMessageManager.h
@@ -103,18 +103,16 @@ protected:
 StructuredCloneData UnpackClonedMessageDataForParent(const ClonedMessageData& aData);
 StructuredCloneData UnpackClonedMessageDataForChild(const ClonedMessageData& aData);
 
 } // namespace ipc
 } // namespace dom
 } // namespace mozilla
 
 class nsAXPCNativeCallContext;
-struct JSContext;
-class JSObject;
 
 struct nsMessageListenerInfo
 {
   // Exactly one of mStrongListener and mWeakListener must be non-null.
   nsCOMPtr<nsIMessageListener> mStrongListener;
   nsWeakPtr mWeakListener;
   nsCOMPtr<nsIAtom> mMessage;
 };

--- a/content/base/src/nsNodeUtils.h
+++ b/content/base/src/nsNodeUtils.h
@@ -3,20 +3,19 @@
  * 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 nsNodeUtils_h___
 #define nsNodeUtils_h___
 
 #include "nsIContent.h"          // for use in inline function (ParentChainChanged)
 #include "nsIMutationObserver.h" // for use in inline function (ParentChainChanged)
+#include "js/TypeDecls.h"
 
 struct CharacterDataChangeInfo;
-struct JSContext;
-class JSObject;
 class nsIVariant;
 class nsIDOMNode;
 class nsIDOMUserDataHandler;
 template<class E> class nsCOMArray;
 class nsCycleCollectionTraversalCallback;
 
 class nsNodeUtils
 {

--- a/content/canvas/src/WebGLActiveInfo.h
+++ b/content/canvas/src/WebGLActiveInfo.h
@@ -4,22 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef WEBGLACTIVEINFO_H_
 #define WEBGLACTIVEINFO_H_
 
 #include "WebGLTypes.h"
 #include "nsISupports.h"
 #include "nsString.h"
-
-struct JSContext;
-class JSObject;
-namespace JS {
-template <typename T> class Handle;
-}
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 
 class WebGLActiveInfo MOZ_FINAL
 {
 public:
     WebGLActiveInfo(WebGLint size, WebGLenum type, const nsACString& name) :
         mSize(size),

--- a/content/events/src/nsDOMEvent.h
+++ b/content/events/src/nsDOMEvent.h
@@ -13,22 +13,21 @@
 #include "nsPIDOMWindow.h"
 #include "nsPoint.h"
 #include "nsGUIEvent.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsAutoPtr.h"
 #include "mozilla/dom/EventBinding.h"
 #include "nsIScriptGlobalObject.h"
 #include "Units.h"
+#include "js/TypeDecls.h"
 
 class nsIContent;
 class nsIDOMEventTarget;
 class nsPresContext;
-struct JSContext;
-class JSObject;
 
 namespace mozilla {
 namespace dom {
 class EventTarget;
 }
 }
 
 // Dummy class so we can cast through it to get from nsISupports to

--- a/content/events/src/nsDOMUIEvent.cpp
+++ b/content/events/src/nsDOMUIEvent.cpp
@@ -343,17 +343,17 @@ nsDOMUIEvent::GetIsChar(bool* aIsChar)
 bool
 nsDOMUIEvent::IsChar() const
 {
   switch (mEvent->eventStructType)
   {
     case NS_KEY_EVENT:
       return static_cast<nsKeyEvent*>(mEvent)->isChar;
     case NS_TEXT_EVENT:
-      return static_cast<nsKeyEvent*>(mEvent)->isChar;
+      return static_cast<nsTextEvent*>(mEvent)->isChar;
     default:
       return false;
   }
   MOZ_CRASH("Switch handles all cases.");
 }
 
 NS_IMETHODIMP
 nsDOMUIEvent::DuplicatePrivateData()

--- a/content/html/content/public/nsIHTMLCollection.h
+++ b/content/html/content/public/nsIHTMLCollection.h
@@ -3,19 +3,18 @@
  * 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 nsIHTMLCollection_h___
 #define nsIHTMLCollection_h___
 
 #include "nsIDOMHTMLCollection.h"
 #include "nsWrapperCache.h"
+#include "js/TypeDecls.h"
 
-struct JSContext;
-class JSObject;
 class nsINode;
 class nsString;
 template<class> class nsTArray;
 
 namespace mozilla {
 class ErrorResult;
 
 namespace dom {

--- a/content/html/content/src/HTMLCanvasElement.cpp
+++ b/content/html/content/src/HTMLCanvasElement.cpp
@@ -1,16 +1,16 @@
 /* -*- 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 "mozilla/dom/HTMLCanvasElement.h"
 
-#include "BasicLayers.h"
+#include "Layers.h"
 #include "imgIEncoder.h"
 #include "jsapi.h"
 #include "jsfriendapi.h"
 #include "mozilla/Base64.h"
 #include "mozilla/CheckedInt.h"
 #include "mozilla/dom/CanvasRenderingContext2D.h"
 #include "mozilla/dom/HTMLCanvasElementBinding.h"
 #include "mozilla/dom/UnionTypes.h"

--- a/content/html/content/src/HTMLMediaElement.cpp
+++ b/content/html/content/src/HTMLMediaElement.cpp
@@ -49,17 +49,17 @@
 #include "nsIDOMHTMLVideoElement.h"
 #include "nsIContentPolicy.h"
 #include "nsContentPolicyUtils.h"
 #include "nsCrossSiteListenerProxy.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsICachingChannel.h"
 #include "nsLayoutUtils.h"
 #include "nsVideoFrame.h"
-#include "BasicLayers.h"
+#include "Layers.h"
 #include <limits>
 #include "nsIAsyncVerifyRedirectCallback.h"
 #include "nsIAppShell.h"
 #include "nsWidgetsCID.h"
 #include "nsIDOMNotifyAudioAvailableEvent.h"
 #include "nsMediaFragmentURIParser.h"
 #include "nsURIHashKey.h"
 #include "nsJSUtils.h"

--- a/content/html/content/src/ValidityState.h
+++ b/content/html/content/src/ValidityState.h
@@ -4,19 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_ValidityState_h
 #define mozilla_dom_ValidityState_h
 
 #include "nsIDOMValidityState.h"
 #include "nsIConstraintValidation.h"
 #include "nsWrapperCache.h"
-
-class JSObject;
-struct JSContext;
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 namespace dom {
 
 class ValidityState MOZ_FINAL : public nsIDOMValidityState,
                                 public nsWrapperCache
 {
 public:

--- a/content/media/AudioNodeEngineNEON.cpp
+++ b/content/media/AudioNodeEngineNEON.cpp
@@ -169,82 +169,58 @@ AudioBlockPanStereoToStereo_NEON(const f
                                  float aOutputL[WEBAUDIO_BLOCK_SIZE],
                                  float aOutputR[WEBAUDIO_BLOCK_SIZE])
 {
   ASSERT_ALIGNED(aInputL);
   ASSERT_ALIGNED(aInputR);
   ASSERT_ALIGNED(aOutputL);
   ASSERT_ALIGNED(aOutputR);
 
-  float32x4_t vinL0, vinL1, vinL2, vinL3;
-  float32x4_t vinR0, vinR1, vinR2, vinR3;
-  float32x4_t voutL0, voutL1, voutL2, voutL3;
-  float32x4_t voutR0, voutR1, voutR2, voutR3;
+  float32x4_t vinL0, vinL1;
+  float32x4_t vinR0, vinR1;
+  float32x4_t voutL0, voutL1;
+  float32x4_t voutR0, voutR1;
   float32x4_t vscaleL = vmovq_n_f32(aGainL);
   float32x4_t vscaleR = vmovq_n_f32(aGainR);
 
   if (aIsOnTheLeft) {
-    for (uint32_t i = 0; i < WEBAUDIO_BLOCK_SIZE; i+=16) {
+    for (uint32_t i = 0; i < WEBAUDIO_BLOCK_SIZE; i+=8) {
       vinL0 = vld1q_f32(ADDRESS_OF(aInputL, i));
       vinL1 = vld1q_f32(ADDRESS_OF(aInputL, i+4));
-      vinL2 = vld1q_f32(ADDRESS_OF(aInputL, i+8));
-      vinL3 = vld1q_f32(ADDRESS_OF(aInputL, i+12));
 
       vinR0 = vld1q_f32(ADDRESS_OF(aInputR, i));
       vinR1 = vld1q_f32(ADDRESS_OF(aInputR, i+4));
-      vinR2 = vld1q_f32(ADDRESS_OF(aInputR, i+8));
-      vinR3 = vld1q_f32(ADDRESS_OF(aInputR, i+12));
 
       voutL0 = vmlaq_f32(vinL0, vinR0, vscaleL);
       voutL1 = vmlaq_f32(vinL1, vinR1, vscaleL);
-      voutL2 = vmlaq_f32(vinL2, vinR2, vscaleL);
-      voutL3 = vmlaq_f32(vinL3, vinR3, vscaleL);
 
       vst1q_f32(ADDRESS_OF(aOutputL, i), voutL0);
       vst1q_f32(ADDRESS_OF(aOutputL, i+4), voutL1);
-      vst1q_f32(ADDRESS_OF(aOutputL, i+8), voutL2);
-      vst1q_f32(ADDRESS_OF(aOutputL, i+12), voutL3);
 
       voutR0 = vmulq_f32(vinR0, vscaleR);
       voutR1 = vmulq_f32(vinR1, vscaleR);
-      voutR2 = vmulq_f32(vinR2, vscaleR);
-      voutR3 = vmulq_f32(vinR3, vscaleR);
 
       vst1q_f32(ADDRESS_OF(aOutputR, i), voutR0);
       vst1q_f32(ADDRESS_OF(aOutputR, i+4), voutR1);
-      vst1q_f32(ADDRESS_OF(aOutputR, i+8), voutR2);
-      vst1q_f32(ADDRESS_OF(aOutputR, i+12), voutR3);
     }
   } else {
-    for (uint32_t i = 0; i < WEBAUDIO_BLOCK_SIZE; i+=16) {
+    for (uint32_t i = 0; i < WEBAUDIO_BLOCK_SIZE; i+=8) {
       vinL0 = vld1q_f32(ADDRESS_OF(aInputL, i));
       vinL1 = vld1q_f32(ADDRESS_OF(aInputL, i+4));
-      vinL2 = vld1q_f32(ADDRESS_OF(aInputL, i+8));
-      vinL3 = vld1q_f32(ADDRESS_OF(aInputL, i+12));
 
       vinR0 = vld1q_f32(ADDRESS_OF(aInputR, i));
       vinR1 = vld1q_f32(ADDRESS_OF(aInputR, i+4));
-      vinR2 = vld1q_f32(ADDRESS_OF(aInputR, i+8));
-      vinR3 = vld1q_f32(ADDRESS_OF(aInputR, i+12));
 
       voutL0 = vmulq_f32(vinL0, vscaleL);
       voutL1 = vmulq_f32(vinL1, vscaleL);
-      voutL2 = vmulq_f32(vinL2, vscaleL);
-      voutL3 = vmulq_f32(vinL3, vscaleL);
 
       vst1q_f32(ADDRESS_OF(aOutputL, i), voutL0);
       vst1q_f32(ADDRESS_OF(aOutputL, i+4), voutL1);
-      vst1q_f32(ADDRESS_OF(aOutputL, i+8), voutL2);
-      vst1q_f32(ADDRESS_OF(aOutputL, i+12), voutL3);
 
       voutR0 = vmlaq_f32(vinR0, vinL0, vscaleR);
       voutR1 = vmlaq_f32(vinR1, vinL1, vscaleR);
-      voutR2 = vmlaq_f32(vinR2, vinL2, vscaleR);
-      voutR3 = vmlaq_f32(vinR3, vinL3, vscaleR);
 
       vst1q_f32(ADDRESS_OF(aOutputR, i), voutR0);
       vst1q_f32(ADDRESS_OF(aOutputR, i+4), voutR1);
-      vst1q_f32(ADDRESS_OF(aOutputR, i+8), voutR2);
-      vst1q_f32(ADDRESS_OF(aOutputR, i+12), voutR3);
     }
   }
 }
-}
\ No newline at end of file
+}

--- a/content/media/webaudio/AudioBuffer.h
+++ b/content/media/webaudio/AudioBuffer.h
@@ -9,19 +9,17 @@
 
 #include "nsWrapperCache.h"
 #include "nsCycleCollectionParticipant.h"
 #include "mozilla/Attributes.h"
 #include "EnableWebAudioCheck.h"
 #include "nsAutoPtr.h"
 #include "nsTArray.h"
 #include "AudioContext.h"
-
-struct JSContext;
-class JSObject;
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 
 class ErrorResult;
 class ThreadSharedFloatArrayBufferList;
 
 namespace dom {
 

--- a/content/media/webaudio/AudioContext.h
+++ b/content/media/webaudio/AudioContext.h
@@ -12,25 +12,24 @@
 #include "mozilla/Attributes.h"
 #include "mozilla/dom/TypedArray.h"
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsDOMEventTargetHelper.h"
 #include "nsHashKeys.h"
 #include "nsTHashtable.h"
+#include "js/TypeDecls.h"
 
 // X11 has a #define for CurrentTime. Unbelievable :-(.
 // See content/media/DOMMediaStream.h for more fun!
 #ifdef CurrentTime
 #undef CurrentTime
 #endif
 
-struct JSContext;
-class JSObject;
 class nsPIDOMWindow;
 
 namespace mozilla {
 
 class DOMMediaStream;
 class ErrorResult;
 class MediaStream;
 class MediaStreamGraph;

--- a/content/media/webaudio/AudioListener.h
+++ b/content/media/webaudio/AudioListener.h
@@ -11,18 +11,17 @@
 #include "nsCycleCollectionParticipant.h"
 #include "mozilla/Attributes.h"
 #include "EnableWebAudioCheck.h"
 #include "nsAutoPtr.h"
 #include "ThreeDPoint.h"
 #include "AudioContext.h"
 #include "PannerNode.h"
 #include "WebAudioUtils.h"
-
-struct JSContext;
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 
 namespace dom {
 
 class AudioListener MOZ_FINAL : public nsWrapperCache,
                                 public EnableWebAudioCheck
 {

--- a/content/media/webaudio/AudioParam.h
+++ b/content/media/webaudio/AudioParam.h
@@ -10,18 +10,17 @@
 #include "AudioParamTimeline.h"
 #include "nsWrapperCache.h"
 #include "nsCycleCollectionParticipant.h"
 #include "EnableWebAudioCheck.h"
 #include "nsAutoPtr.h"
 #include "AudioNode.h"
 #include "mozilla/dom/TypedArray.h"
 #include "WebAudioUtils.h"
-
-struct JSContext;
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 
 namespace dom {
 
 class AudioParam MOZ_FINAL : public nsWrapperCache,
                              public EnableWebAudioCheck,
                              public AudioParamTimeline

--- a/content/media/webaudio/DelayProcessor.cpp
+++ b/content/media/webaudio/DelayProcessor.cpp
@@ -33,19 +33,17 @@ DelayProcessor::Process(const double *aP
     const float* input = aInputChannels ? aInputChannels[channel] : nullptr;
     float* output = aOutputChannels[channel];
 
     for (int i = 0; i < aFramesToProcess; ++i) {
       currentDelayFrames = clamped(aPerFrameDelays[i],
                                    0.0, static_cast<double>(mMaxDelayFrames));
 
       // Write the input sample to the correct location in our buffer
-      if (input) {
-        buffer[writeIndex] = input[i];
-      }
+      buffer[writeIndex] = input ? input[i] : 0.0f;
 
       // Now, determine the correct read position.  We adjust the read position to be
       // from currentDelayFrames frames in the past.  We also interpolate the two input
       // frames in case the read position does not match an integer index.
       double readPosition = writeIndex + bufferLength - currentDelayFrames;
       if (readPosition >= bufferLength) {
         readPosition -= bufferLength;
       }
@@ -104,17 +102,20 @@ DelayProcessor::EnsureBuffer(uint32_t aN
 {
   if (aNumberOfChannels == 0) {
     return false;
   }
   if (mBuffer.Length() == 0) {
     if (!mBuffer.SetLength(aNumberOfChannels)) {
       return false;
     }
-    const int numFrames = mMaxDelayFrames;
+    // The length of the buffer is one greater than the maximum delay so that
+    // writing an input frame does not overwrite the frame that would
+    // subsequently be read at maximum delay.
+    const int numFrames = mMaxDelayFrames + 1;
     for (uint32_t channel = 0; channel < aNumberOfChannels; ++channel) {
       if (!mBuffer[channel].SetLength(numFrames)) {
         return false;
       }
       PodZero(mBuffer[channel].Elements(), numFrames);
     }
   } else if (mBuffer.Length() != aNumberOfChannels) {
     // TODO: Handle changes in the channel count

--- a/content/media/webaudio/test/Makefile.in
+++ b/content/media/webaudio/test/Makefile.in
@@ -52,19 +52,21 @@ MOCHITEST_FILES := \
   test_audioBufferSourceNodeNullBuffer.html \
   test_badConnect.html \
   test_biquadFilterNode.html \
   test_channelMergerNode.html \
   test_channelMergerNodeWithVolume.html \
   test_channelSplitterNode.html \
   test_channelSplitterNodeWithVolume.html \
   test_convolverNode.html \
+  test_convolverNodeWithGain.html \
   test_convolverNode_mono_mono.html \
   test_currentTime.html \
   test_delayNode.html \
+  test_delayNodeAtMax.html \
   test_delayNodeSmallMaxDelay.html \
   test_delayNodeWithGain.html \
   test_dynamicsCompressorNode.html \
   test_gainNode.html \
   test_gainNodeInLoop.html \
   test_maxChannelCount.html \
   test_mediaDecoding.html \
   test_decodeMultichannel.html \

new file mode 100644
--- /dev/null
+++ b/content/media/webaudio/test/test_convolverNodeWithGain.html
@@ -0,0 +1,62 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test ConvolverNode after a GainNode - Bug 891254 </title>
+  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<pre id="test">
+<script src="webaudio.js" type="text/javascript"></script>
+<script class="testbody" type="text/javascript">
+
+const signalLength = 2048;
+const responseLength = 100;
+const outputLength = 4096; // > signalLength + responseLength
+
+var gTest = {
+  length: outputLength,
+  numberOfChannels: 1,
+  createGraph: function(context) {
+    var buffer = context.createBuffer(1, signalLength, context.sampleRate);
+    for (var i = 0; i < signalLength; ++i) {
+      buffer.getChannelData(0)[i] = Math.sin(2 * Math.PI * i / signalLength);
+    }
+
+    var source = context.createBufferSource();
+    source.buffer = buffer;
+    source.start(0);
+
+    var response = context.createBuffer(1, responseLength, context.sampleRate);
+    for (var i = 0; i < responseLength; ++i) {
+      response.getChannelData(0)[i] = i / responseLength;
+    }
+
+    var gain = context.createGain();
+    gain.gain.value = -1;
+    source.connect(gain);
+
+    var convolver1 = context.createConvolver();
+    convolver1.buffer = response;
+    gain.connect(convolver1);
+
+    var convolver2 = context.createConvolver();
+    convolver2.buffer = response;
+    source.connect(convolver2);
+
+    // The output of convolver1 should be the inverse of convolver2, so blend
+    // them together and expect silence.
+    var blend = context.createGain();
+    convolver1.connect(blend);
+    convolver2.connect(blend);
+
+    return blend;
+  },
+};
+
+runTest();
+
+</script>
+</pre>
+</body>
+</html>

new file mode 100644
--- /dev/null
+++ b/content/media/webaudio/test/test_delayNodeAtMax.html
@@ -0,0 +1,53 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test DelayNode with maxDelayTime delay - bug 890528</title>
+  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<pre id="test">
+<script src="webaudio.js" type="text/javascript"></script>
+<script class="testbody" type="text/javascript">
+
+const signalLength = 2048;
+const delayLength = 1000; // Not on a block boundary
+const outputLength = 4096 // > signalLength + 2 * delayLength;
+
+function applySignal(buffer, offset) {
+  for (var i = 0; i < signalLength; ++i) {
+    buffer.getChannelData(0)[offset + i] = Math.cos(Math.PI * i / signalLength);
+  }
+}
+
+var gTest = {
+  numberOfChannels: 1,
+  createGraph: function(context) {
+    var buffer = context.createBuffer(1, signalLength, context.sampleRate);
+    applySignal(buffer, 0);
+
+    var source = context.createBufferSource();
+    source.buffer = buffer;
+
+    const delayTime = delayLength / context.sampleRate;
+    var delay = context.createDelay(delayTime);
+    delay.delayTime.value = delayTime;
+
+    source.connect(delay);
+
+    source.start(0);
+    return delay;
+  },
+  createExpectedBuffers: function(context) {
+    var expectedBuffer = context.createBuffer(1, outputLength, context.sampleRate);
+    applySignal(expectedBuffer, delayLength);
+    return expectedBuffer;
+  },
+};
+
+runTest();
+
+</script>
+</pre>
+</body>
+</html>

--- a/content/media/webaudio/test/webaudio.js
+++ b/content/media/webaudio/test/webaudio.js
@@ -63,35 +63,41 @@ function compareBuffers(buf1, buf2,
 function getEmptyBuffer(context, length) {
   return context.createBuffer(gTest.numberOfChannels, length, context.sampleRate);
 }
 
 /**
  * This function assumes that the test file defines a single gTest variable with
  * the following properties and methods:
  *
- * + length: mandatory property equal to the total number of frames which we
- *           are waiting to see in the output.
  * + numberOfChannels: optional property which specifies the number of channels
  *                     in the output.  The default value is 2.
  * + createGraph: mandatory method which takes a context object and does
  *                everything needed in order to set up the Web Audio graph.
  *                This function returns the node to be inspected.
  * + createGraphAsync: async version of createGraph.  This function takes
  *                     a callback which should be called with an argument
  *                     set to the node to be inspected when the callee is
  *                     ready to proceed with the test.  Either this function
  *                     or createGraph must be provided.
  * + createExpectedBuffers: optional method which takes a context object and
  *                          returns either one expected buffer or an array of
  *                          them, designating what is expected to be observed
  *                          in the output.  If omitted, the output is expected
- *                          to be silence.  The sum of the length of the expected
- *                          buffers should be equal to gTest.length.  This
- *                          function is guaranteed to be called before createGraph.
+ *                          to be silence.  All buffers must have the same
+ *                          length, which must be a bufferSize supported by
+ *                          ScriptProcessorNode.  This function is guaranteed
+ *                          to be called before createGraph.
+ * + length: property equal to the total number of frames which we are waiting
+ *           to see in the output, mandatory if createExpectedBuffers is not
+ *           provided, in which case it must be a bufferSize supported by
+ *           ScriptProcessorNode (256, 512, 1024, 2048, 4096, 8192, or 16384).
+ *           If createExpectedBuffers is provided then this must be equal to
+ *           the number of expected buffers * the expected buffer length.
+ *
  * + skipOfflineContextTests: optional. when true, skips running tests on an offline
  *                            context by circumventing testOnOfflineContext.
  */
 function runTest()
 {
   function done() {
     SimpleTest.finish();
   }
@@ -115,17 +121,19 @@ function runTest()
         expectedBuffers = [expectedBuffers];
       }
       var expectedFrames = 0;
       for (var i = 0; i < expectedBuffers.length; ++i) {
         is(expectedBuffers[i].numberOfChannels, gTest.numberOfChannels,
            "Correct number of channels for expected buffer " + i);
         expectedFrames += expectedBuffers[i].length;
       }
-      is(expectedFrames, gTest.length, "Correct number of expected frames");
+      if (gTest.length && gTest.createExpectedBuffers) {
+        is(expectedFrames, gTest.length, "Correct number of expected frames");
+      }
 
       if (gTest.createGraphAsync) {
         gTest.createGraphAsync(context, function(nodeToInspect) {
           testOutput(nodeToInspect, expectedBuffers, callback);
         });
       } else {
         testOutput(gTest.createGraph(context), expectedBuffers, callback);
       }

--- a/content/media/webspeech/recognition/SpeechGrammar.h
+++ b/content/media/webspeech/recognition/SpeechGrammar.h
@@ -5,24 +5,23 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #pragma once
 
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsString.h"
 #include "nsWrapperCache.h"
+#include "js/TypeDecls.h"
 
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 
 #include "EnableWebSpeechRecognitionCheck.h"
 
-struct JSContext;
-
 namespace mozilla {
 namespace dom {
 
 class GlobalObject;
 
 class SpeechGrammar MOZ_FINAL : public nsISupports,
                                 public nsWrapperCache,
                                 public EnableWebSpeechRecognitionCheck

--- a/content/media/webspeech/recognition/SpeechGrammarList.h
+++ b/content/media/webspeech/recognition/SpeechGrammarList.h
@@ -4,25 +4,24 @@
  * 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/. */
 
 #pragma once
 
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
+#include "js/TypeDecls.h"
 
 #include "mozilla/Attributes.h"
 #include "mozilla/dom/BindingUtils.h"
 
 #include "EnableWebSpeechRecognitionCheck.h"
 #include "SpeechGrammar.h"
 
-struct JSContext;
-
 namespace mozilla {
 namespace dom {
 
 class GlobalObject;
 class SpeechGrammarList MOZ_FINAL : public nsISupports,
                                     public nsWrapperCache,
                                     public EnableWebSpeechRecognitionCheck
 {

--- a/content/media/webspeech/recognition/SpeechRecognition.h
+++ b/content/media/webspeech/recognition/SpeechRecognition.h
@@ -7,16 +7,17 @@
 #pragma once
 
 #include "mozilla/Attributes.h"
 #include "nsCOMPtr.h"
 #include "nsDOMEventTargetHelper.h"
 #include "nsString.h"
 #include "nsWrapperCache.h"
 #include "nsTArray.h"
+#include "js/TypeDecls.h"
 
 #include "nsIDOMNavigatorUserMedia.h"
 #include "nsITimer.h"
 #include "MediaEngine.h"
 #include "MediaStreamGraph.h"
 #include "AudioSegment.h"
 #include "mozilla/WeakPtr.h"
 #include "mozilla/Preferences.h"
@@ -25,17 +26,16 @@
 #include "SpeechGrammarList.h"
 #include "SpeechRecognitionResultList.h"
 #include "SpeechStreamListener.h"
 #include "nsISpeechRecognitionService.h"
 #include "endpointer.h"
 
 #include "mozilla/dom/SpeechRecognitionError.h"
 
-struct JSContext;
 class nsIDOMWindow;
 
 namespace mozilla {
 
 namespace dom {
 
 #define TEST_PREFERENCE_ENABLE "media.webspeech.test.enable"
 #define TEST_PREFERENCE_FAKE_FSM_EVENTS "media.webspeech.test.fake_fsm_events"

--- a/content/media/webspeech/recognition/SpeechRecognitionAlternative.h
+++ b/content/media/webspeech/recognition/SpeechRecognitionAlternative.h
@@ -5,23 +5,22 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #pragma once
 
 #include "nsCycleCollectionParticipant.h"
 #include "nsString.h"
 #include "nsWrapperCache.h"
 #include "nsAutoPtr.h"
+#include "js/TypeDecls.h"
 
 #include "mozilla/Attributes.h"
 
 #include "EnableWebSpeechRecognitionCheck.h"
 
-struct JSContext;
-
 namespace mozilla {
 namespace dom {
 
 class SpeechRecognition;
 
 class SpeechRecognitionAlternative MOZ_FINAL : public nsISupports,
                                                public nsWrapperCache,
                                                public EnableWebSpeechRecognitionCheck

--- a/content/media/webspeech/recognition/SpeechRecognitionResult.h
+++ b/content/media/webspeech/recognition/SpeechRecognitionResult.h
@@ -6,24 +6,23 @@
 
 #pragma once
 
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
 #include "nsAutoPtr.h"
 #include "nsTArray.h"
+#include "js/TypeDecls.h"
 
 #include "mozilla/Attributes.h"
 
 #include "EnableWebSpeechRecognitionCheck.h"
 #include "SpeechRecognitionAlternative.h"
 
-struct JSContext;
-
 namespace mozilla {
 namespace dom {
 
 class SpeechRecognitionResult MOZ_FINAL : public nsISupports,
                                           public nsWrapperCache,
                                           public EnableWebSpeechRecognitionCheck
 {
 public:

--- a/content/media/webspeech/recognition/SpeechRecognitionResultList.h
+++ b/content/media/webspeech/recognition/SpeechRecognitionResultList.h
@@ -5,24 +5,23 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #pragma once
 
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
 #include "nsAutoPtr.h"
 #include "nsTArray.h"
+#include "js/TypeDecls.h"
 
 #include "mozilla/Attributes.h"
 
 #include "EnableWebSpeechRecognitionCheck.h"
 #include "SpeechRecognitionResult.h"
 
-struct JSContext;
-
 namespace mozilla {
 namespace dom {
 
 class SpeechRecognition;
 
 class SpeechRecognitionResultList MOZ_FINAL : public nsISupports,
                                               public nsWrapperCache,
                                               public EnableWebSpeechRecognitionCheck

--- a/content/media/webspeech/synth/SpeechSynthesis.h
+++ b/content/media/webspeech/synth/SpeechSynthesis.h
@@ -5,22 +5,22 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #pragma once
 
 #include "nsCOMPtr.h"
 #include "nsString.h"
 #include "nsWrapperCache.h"
 #include "nsRefPtrHashtable.h"
+#include "js/TypeDecls.h"
 
 #include "EnableSpeechSynthesisCheck.h"
 #include "SpeechSynthesisUtterance.h"
 #include "SpeechSynthesisVoice.h"
 
-struct JSContext;
 class nsIDOMWindow;
 
 namespace mozilla {
 namespace dom {
 
 class nsSpeechTask;
 
 class SpeechSynthesis MOZ_FINAL : public nsISupports,

--- a/content/media/webspeech/synth/SpeechSynthesisUtterance.h
+++ b/content/media/webspeech/synth/SpeechSynthesisUtterance.h
@@ -4,22 +4,21 @@
  * 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/. */
 
 #pragma once
 
 #include "nsCOMPtr.h"
 #include "nsDOMEventTargetHelper.h"
 #include "nsString.h"
+#include "js/TypeDecls.h"
 
 #include "EnableSpeechSynthesisCheck.h"
 #include "nsSpeechTask.h"
 
-struct JSContext;
-
 namespace mozilla {
 namespace dom {
 
 class SpeechSynthesisVoice;
 class SpeechSynthesis;
 class nsSynthVoiceRegistry;
 
 class SpeechSynthesisUtterance MOZ_FINAL : public nsDOMEventTargetHelper,

--- a/content/media/webspeech/synth/SpeechSynthesisVoice.h
+++ b/content/media/webspeech/synth/SpeechSynthesisVoice.h
@@ -4,22 +4,21 @@
  * 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/. */
 
 #pragma once
 
 #include "nsCOMPtr.h"
 #include "nsString.h"
 #include "nsWrapperCache.h"
+#include "js/TypeDecls.h"
 
 #include "EnableSpeechSynthesisCheck.h"
 #include "nsISpeechService.h"
 
-struct JSContext;
-
 namespace mozilla {
 namespace dom {
 
 class nsSynthVoiceRegistry;
 class SpeechSynthesis;
 
 class SpeechSynthesisVoice MOZ_FINAL : public nsISupports,
                                        public nsWrapperCache,

--- a/content/xbl/src/nsXBLBinding.h
+++ b/content/xbl/src/nsXBLBinding.h
@@ -10,34 +10,33 @@
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
 #include "nsINodeList.h"
 #include "nsIStyleRuleProcessor.h"
 #include "nsClassHashtable.h"
 #include "nsTArray.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsISupportsImpl.h"
+#include "js/TypeDecls.h"
 
 class nsXBLPrototypeBinding;
 class nsIContent;
 class nsIAtom;
 class nsIDocument;
 class nsIScriptContext;
 
 namespace mozilla {
 namespace dom {
 
 class XBLChildrenElement;
 
 }
 }
 
 class nsAnonymousContentList;
-struct JSContext;
-class JSObject;
 
 // *********************************************************************/
 // The XBLBinding class
 
 class nsXBLBinding
 {
 public:
   nsXBLBinding(nsXBLPrototypeBinding* aProtoBinding);

--- a/content/xbl/src/nsXBLPrototypeHandler.h
+++ b/content/xbl/src/nsXBLPrototypeHandler.h
@@ -10,31 +10,27 @@
 #include "nsString.h"
 #include "nsCOMPtr.h"
 #include "nsIController.h"
 #include "nsAutoPtr.h"
 #include "nsXBLEventHandler.h"
 #include "nsIWeakReference.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsCycleCollectionParticipant.h"
+#include "js/TypeDecls.h"
 
-class JSObject;
 class nsIDOMEvent;
 class nsIContent;
 class nsIDOMUIEvent;
 class nsIDOMKeyEvent;
 class nsIDOMMouseEvent;
 class nsIObjectInputStream;
 class nsIObjectOutputStream;
 class nsXBLPrototypeBinding;
 
-namespace JS {
-template <typename T> class MutableHandle;
-}
-
 namespace mozilla {
 namespace dom {
 class EventTarget;
 }
 }
 
 #define NS_HANDLER_TYPE_XBL_JS              (1 << 0)
 #define NS_HANDLER_TYPE_XBL_COMMAND         (1 << 1)

--- a/content/xbl/src/nsXBLSerialize.h
+++ b/content/xbl/src/nsXBLSerialize.h
@@ -4,21 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsXBLSerialize_h__
 #define nsXBLSerialize_h__
 
 #include "nsIObjectInputStream.h"
 #include "nsIObjectOutputStream.h"
 #include "nsINameSpaceManager.h"
-
-namespace JS {
-template <typename T> class Handle;
-template <typename T> class MutableHandle;
-}
+#include "js/TypeDecls.h"
 
 typedef uint8_t XBLBindingSerializeDetails;
 
 // A version number to ensure we don't load cached data in a different
 // file format.
 #define XBLBinding_Serialize_Version 0x00000002
 
 // Set for the first binding in a document

--- a/content/xul/document/src/XULDocument.h
+++ b/content/xul/document/src/XULDocument.h
@@ -20,32 +20,33 @@
 #include "nsIURI.h"
 #include "nsIXULDocument.h"
 #include "nsScriptLoader.h"
 #include "nsIStreamListener.h"
 #include "nsICSSLoaderObserver.h"
 
 #include "mozilla/Attributes.h"
 
+#include "js/TypeDecls.h"
+
 class nsIRDFResource;
 class nsIRDFService;
 class nsPIWindowRoot;
 #if 0 // XXXbe save me, scc (need NSCAP_FORWARD_DECL(nsXULPrototypeScript))
 class nsIObjectInputStream;
 class nsIObjectOutputStream;
 class nsIXULPrototypeScript;
 #else
 #include "nsIObjectInputStream.h"
 #include "nsIObjectOutputStream.h"
 #include "nsXULElement.h"
 #endif
 #include "nsURIHashKey.h"
 #include "nsInterfaceHashtable.h"
 
-class JSObject;
 struct JSTracer;
 struct PRLogModuleInfo;
 
 class nsRefMapEntry : public nsStringHashKey
 {
 public:
   nsRefMapEntry(const nsAString& aKey) :
     nsStringHashKey(&aKey)

--- a/docshell/base/nsIDocShell.idl
+++ b/docshell/base/nsIDocShell.idl
@@ -4,19 +4,19 @@
  * 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 "domstubs.idl"
 #include "nsIDocShellTreeItem.idl"
 #include "nsIAtom.idl"
 
 %{ C++
+#include "js/TypeDecls.h"
 class nsPresContext;
 class nsIPresShell;
-struct JSContext;
 %}
 
 /**
  * The nsIDocShell interface.
  */
 
 [ptr] native nsPresContext(nsPresContext);
 [ptr] native nsIPresShell(nsIPresShell);

--- a/dom/base/nsIGlobalObject.h
+++ b/dom/base/nsIGlobalObject.h
@@ -3,18 +3,17 @@
  * 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 nsIGlobalObject_h__
 #define nsIGlobalObject_h__
 
 #include "nsISupports.h"
 #include "nsIScriptObjectPrincipal.h"
-
-class JSObject;
+#include "js/TypeDecls.h"
 
 #define NS_IGLOBALOBJECT_IID \
 { 0x8503e9a9, 0x530, 0x4b26,  \
 { 0xae, 0x24, 0x18, 0xca, 0x38, 0xe5, 0xed, 0x17 } }
 
 class nsIGlobalObject : public nsIScriptObjectPrincipal
 {
 public:

--- a/dom/base/nsIScriptGlobalObject.h
+++ b/dom/base/nsIScriptGlobalObject.h
@@ -5,21 +5,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsIScriptGlobalObject_h__
 #define nsIScriptGlobalObject_h__
 
 #include "nsISupports.h"
 #include "nsEvent.h"
 #include "nsIGlobalObject.h"
+#include "js/TypeDecls.h"
 
 class nsIScriptContext;
 class nsScriptErrorEvent;
 class nsIScriptGlobalObject;
-class JSObject;
 
 // A helper function for nsIScriptGlobalObject implementations to use
 // when handling a script error.  Generally called by the global when a context
 // notifies it of an error via nsIScriptGlobalObject::HandleScriptError.
 // Returns true if HandleDOMEvent was actually called, in which case
 // aStatus will be filled in with the status.
 bool
 NS_HandleScriptError(nsIScriptGlobalObject *aScriptGlobal,

--- a/dom/base/nsIScriptTimeoutHandler.h
+++ b/dom/base/nsIScriptTimeoutHandler.h
@@ -2,20 +2,18 @@
 /* vim: set ts=2 sw=2 et tw=80: */
 /* 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 nsIScriptTimeoutHandler_h___
 #define nsIScriptTimeoutHandler_h___
 
 #include "nsTArray.h"
+#include "js/TypeDecls.h"
 
-namespace JS {
-class Value;
-} // namespace JS
 namespace mozilla {
 namespace dom {
 class Function;
 } // namespace dom
 } // namespace mozilla
 
 #define NS_ISCRIPTTIMEOUTHANDLER_IID \
 { 0x53c8e80e, 0xcc78, 0x48bc, \

--- a/dom/base/nsLocation.h
+++ b/dom/base/nsLocation.h
@@ -7,20 +7,20 @@
 #ifndef nsLocation_h__
 #define nsLocation_h__
 
 #include "nsIDOMLocation.h"
 #include "nsString.h"
 #include "nsIWeakReferenceUtils.h"
 #include "nsWrapperCache.h"
 #include "nsCycleCollectionParticipant.h"
+#include "js/TypeDecls.h"
 
 class nsIURI;
 class nsIDocShell;
-struct JSContext;
 class nsIDocShellLoadInfo;
 
 //*****************************************************************************
 // nsLocation: Script "location" object
 //*****************************************************************************
 
 class nsLocation : public nsIDOMLocation
                  , public nsWrapperCache

--- a/dom/base/nsPIDOMWindow.h
+++ b/dom/base/nsPIDOMWindow.h
@@ -9,39 +9,35 @@
 #define nsPIDOMWindow_h__
 
 #include "nsIDOMWindow.h"
 
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
 #include "nsTArray.h"
 #include "mozilla/dom/EventTarget.h"
+#include "js/TypeDecls.h"
 
 #define DOM_WINDOW_DESTROYED_TOPIC "dom-window-destroyed"
 #define DOM_WINDOW_FROZEN_TOPIC "dom-window-frozen"
 #define DOM_WINDOW_THAWED_TOPIC "dom-window-thawed"
 
-class JSObject;
 class nsIArray;
 class nsIContent;
 class nsIDocShell;
 class nsIDocument;
 class nsIIdleObserver;
 class nsIPrincipal;
 class nsIScriptTimeoutHandler;
 class nsIURI;
 class nsPerformance;
 class nsPIWindowRoot;
 class nsXBLPrototypeHandler;
 struct nsTimeout;
 
-namespace JS {
-template<typename> class Handle;
-}
-
 namespace mozilla {
 namespace dom {
 class AudioContext;
 class Element;
 }
 }
 
 // Popup control state enum. The values in this enum must go from most

--- a/dom/base/nsPIWindowRoot.h
+++ b/dom/base/nsPIWindowRoot.h
@@ -8,17 +8,16 @@
 #define nsPIWindowRoot_h__
 
 #include "nsISupports.h"
 #include "mozilla/dom/EventTarget.h"
 
 class nsPIDOMWindow;
 class nsIControllers;
 class nsIController;
-struct JSContext;
 
 #define NS_IWINDOWROOT_IID \
 { 0x3f71f50c, 0xa7e0, 0x43bc, \
  { 0xac, 0x25, 0x4d, 0xbb, 0x88, 0x7b, 0x21, 0x09 } }
 
 class nsPIWindowRoot : public mozilla::dom::EventTarget
 {
 public:

--- a/dom/base/nsPerformance.h
+++ b/dom/base/nsPerformance.h
@@ -7,21 +7,20 @@
 
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
 #include "mozilla/Attributes.h"
 #include "nsWrapperCache.h"
 #include "nsDOMNavigationTiming.h"
 #include "nsContentUtils.h"
 #include "nsIDOMWindow.h"
+#include "js/TypeDecls.h"
 
 class nsITimedChannel;
 class nsPerformance;
-class JSObject;
-struct JSContext;
 
 // Script "performance.timing" object
 class nsPerformanceTiming MOZ_FINAL : public nsWrapperCache
 {
 public:
   nsPerformanceTiming(nsPerformance* aPerformance,
                       nsITimedChannel* aChannel);
   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(nsPerformanceTiming)

--- a/dom/base/nsWrapperCache.h
+++ b/dom/base/nsWrapperCache.h
@@ -8,18 +8,16 @@
 
 #include "nsCycleCollectionParticipant.h"
 #include "mozilla/Assertions.h"
 #include "js/Id.h"          // must come before js/RootingAPI.h
 #include "js/Value.h"       // must come before js/RootingAPI.h
 #include "js/RootingAPI.h"
 
 struct JSTracer;
-class JSObject;
-struct JSContext;
 class XPCWrappedNativeScope;
 
 namespace mozilla {
 namespace dom {
 namespace workers {
 
 class DOMBindingBase;
 

--- a/dom/bindings/BindingDeclarations.h
+++ b/dom/bindings/BindingDeclarations.h
@@ -18,18 +18,16 @@
 #include "js/RootingAPI.h"
 #include "mozilla/Maybe.h"
 #include "nsCOMPtr.h"
 #include "nsDOMString.h"
 #include "nsStringBuffer.h"
 #include "nsTArray.h"
 #include "nsAutoPtr.h" // for nsRefPtr member variables
 
-struct JSContext;
-class JSObject;
 class nsWrapperCache;
 
 // nsGlobalWindow implements nsWrapperCache, but doesn't always use it. Don't
 // try to use it without fixing that first.
 class nsGlobalWindow;
 
 namespace mozilla {
 namespace dom {

--- a/dom/bindings/Date.h
+++ b/dom/bindings/Date.h
@@ -4,23 +4,17 @@
  * 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/. */
 
 /* Representation for dates. */
 
 #ifndef mozilla_dom_Date_h
 #define mozilla_dom_Date_h
 
-class JSObject;
-struct JSContext;
-
-namespace JS {
-class Value;
-template<typename> class MutableHandle;
-} // namespace JS
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 namespace dom {
 
 class Date
 {
 public:
   // Not inlining much here to avoid the includes we'd need.

--- a/dom/bindings/ErrorResult.h
+++ b/dom/bindings/ErrorResult.h
@@ -13,18 +13,16 @@
 
 #include <stdarg.h>
 
 #include "js/Value.h"
 #include "nscore.h"
 #include "nsStringGlue.h"
 #include "mozilla/Assertions.h"
 
-struct JSContext;
-
 namespace mozilla {
 
 namespace dom {
 
 enum ErrNum {
 #define MSG_DEF(_name, _argc, _str) \
   _name,
 #include "mozilla/dom/Errors.msg"

--- a/dom/bluetooth/BluetoothUtils.h
+++ b/dom/bluetooth/BluetoothUtils.h
@@ -3,19 +3,17 @@
 /* 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_bluetooth_bluetoothutils_h__
 #define mozilla_dom_bluetooth_bluetoothutils_h__
 
 #include "BluetoothCommon.h"
-
-struct JSContext;
-class JSObject;
+#include "js/TypeDecls.h"
 
 BEGIN_BLUETOOTH_NAMESPACE
 
 class BluetoothNamedValue;
 class BluetoothValue;
 class BluetoothReplyRunnable;
 
 bool

--- a/dom/cellbroadcast/src/CellBroadcast.h
+++ b/dom/cellbroadcast/src/CellBroadcast.h
@@ -5,19 +5,17 @@
 
 #ifndef mozilla_dom_CellBroadcast_h__
 #define mozilla_dom_CellBroadcast_h__
 
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 #include "nsDOMEventTargetHelper.h"
 #include "nsICellBroadcastProvider.h"
-
-class JSObject;
-struct JSContext;
+#include "js/TypeDecls.h"
 
 class nsPIDOMWindow;
 
 namespace mozilla {
 namespace dom {
 
 class CellBroadcast MOZ_FINAL : public nsDOMEventTargetHelper
 {

--- a/dom/interfaces/base/nsIDOMHistory.idl
+++ b/dom/interfaces/base/nsIDOMHistory.idl
@@ -1,16 +1,12 @@
 /* -*- 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/. */
 
 #include "domstubs.idl"
 
-%{ C++
-struct JSContext;
-%}
-
 [scriptable, uuid(55226663-fe68-48ba-addf-08e32eaab569)]
 interface nsIDOMHistory : nsISupports
 {
   // Empty interface that exists only for extension backwards compat
 };

--- a/dom/interfaces/base/nsIStructuredCloneContainer.idl
+++ b/dom/interfaces/base/nsIStructuredCloneContainer.idl
@@ -6,17 +6,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsISupports.idl"
 
 interface nsIVariant;
 interface nsIDocument;
 
 %{C++
-struct JSContext;
+#include "js/TypeDecls.h"
 %}
 
 /**
  * This interface acts as a container for an object serialized using the
  * structured clone algorithm.
  *
  * You can copy an object into an nsIStructuredCloneContainer using
  * initFromVariant or initFromBase64.  It's an error to initialize an

--- a/dom/interfaces/events/nsIDOMEventTarget.idl
+++ b/dom/interfaces/events/nsIDOMEventTarget.idl
@@ -3,29 +3,29 @@
  * 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 "domstubs.idl"
 
 %{C++
 #include "nsEvent.h"
 #include "mozilla/dom/Nullable.h"
+#include "js/TypeDecls.h"
 
 using mozilla::dom::Nullable;
 
 namespace mozilla {
 namespace dom {
 class EventTarget;
 } // namespace dom
 } // namespace mozilla
 
 class nsPresContext;
 class nsEventChainPreVisitor;
 class nsEventChainPostVisitor;
-struct JSContext;
 class nsEventListenerManager;
 %}
 
 /**
  * The nsIDOMEventTarget interface is the interface implemented by all
  * event targets in the Document Object Model.
  *
  * For more information on this interface please see 

--- a/dom/interfaces/json/nsIJSON.idl
+++ b/dom/interfaces/json/nsIJSON.idl
@@ -8,17 +8,17 @@
 interface nsIInputStream;
 interface nsIOutputStream;
 interface nsIScriptGlobalObject;
 
 [ptr] native JSValPtr(JS::Value);
 [ptr] native JSContext(JSContext);
 
 %{C++
-namespace JS { class Value; }
+#include "js/TypeDecls.h"
 %}
 
 /**
  * Don't use this!  Use JSON.parse and JSON.stringify directly.
  */
 [scriptable, uuid(083aebb0-7790-43b2-ae81-9e404e626236)]
 interface nsIJSON : nsISupports
 {

--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -3,17 +3,17 @@
 /* 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 "base/basictypes.h"
 
 #include "TabChild.h"
 
-#include "BasicLayers.h"
+#include "Layers.h"
 #include "Blob.h"
 #include "ContentChild.h"
 #include "IndexedDBChild.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/IntentionalCrash.h"
 #include "mozilla/docshell/OfflineCacheUpdateChild.h"
 #include "mozilla/dom/PContentChild.h"
 #include "mozilla/dom/PContentDialogChild.h"

--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -17,20 +17,19 @@
 #include "nsCOMPtr.h"
 #include "nsIAuthPromptProvider.h"
 #include "nsIBrowserDOMWindow.h"
 #include "nsIDialogParamBlock.h"
 #include "nsISecureBrowserUI.h"
 #include "nsITabParent.h"
 #include "nsWeakReference.h"
 #include "Units.h"
+#include "js/TypeDecls.h"
 
 struct gfxMatrix;
-struct JSContext;
-class JSObject;
 class mozIApplication;
 class nsFrameLoader;
 class nsIURI;
 class CpowHolder;
 
 namespace mozilla {
 
 namespace layers {

--- a/dom/network/src/TCPServerSocketChild.h
+++ b/dom/network/src/TCPServerSocketChild.h
@@ -6,18 +6,16 @@
 #include "nsITCPServerSocketChild.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsCOMPtr.h"
 
 #define TCPSERVERSOCKETCHILD_CID \
   { 0x41a77ec8, 0xfd86, 0x409e, { 0xae, 0xa9, 0xaf, 0x2c, 0xa4, 0x07, 0xef, 0x8e } }
 
 class nsITCPServerSocketInternal;
-struct JSContext;
-struct JSObject;
 
 namespace mozilla {
 namespace dom {
 
 class TCPServerSocketChildBase : public nsITCPServerSocketChild {
 public:
   NS_DECL_CYCLE_COLLECTION_CLASS(TCPServerSocketChildBase)
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

--- a/dom/network/src/TCPServerSocketParent.h
+++ b/dom/network/src/TCPServerSocketParent.h
@@ -5,19 +5,16 @@
 #include "mozilla/net/PNeckoParent.h"
 #include "mozilla/net/PTCPServerSocketParent.h"
 #include "nsITCPSocketParent.h"
 #include "nsITCPServerSocketParent.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsCOMPtr.h"
 #include "nsIDOMTCPSocket.h"
 
-struct JSContext;
-struct JSObject;
-
 namespace mozilla {
 namespace dom {
 
 class PBrowserParent;
 
 class TCPServerSocketParent : public mozilla::net::PTCPServerSocketParent
                             , public nsITCPServerSocketParent
 {

--- a/dom/network/src/TCPSocketChild.h
+++ b/dom/network/src/TCPSocketChild.h
@@ -1,23 +1,22 @@
 /* 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 "mozilla/net/PTCPSocketChild.h"
 #include "nsITCPSocketChild.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsCOMPtr.h"
+#include "js/TypeDecls.h"
 
 #define TCPSOCKETCHILD_CID \
   { 0xa589d96f, 0x7e09, 0x4edf, { 0xa0, 0x1a, 0xeb, 0x49, 0x51, 0xf4, 0x2f, 0x37 } }
 
 class nsITCPSocketInternal;
-struct JSContext;
-class JSObject;
 
 namespace mozilla {
 namespace dom {
 
 class TCPSocketChildBase : public nsITCPSocketChild {
 public:
   NS_DECL_CYCLE_COLLECTION_CLASS(TCPSocketChildBase)
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

--- a/dom/network/src/TCPSocketParent.h
+++ b/dom/network/src/TCPSocketParent.h
@@ -2,19 +2,17 @@
  * 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 "mozilla/net/PTCPSocketParent.h"
 #include "nsITCPSocketParent.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsCOMPtr.h"
 #include "nsIDOMTCPSocket.h"
-
-struct JSContext;
-class JSObject;
+#include "js/TypeDecls.h"
 
 #define TCPSOCKETPARENT_CID \
   { 0x4e7246c6, 0xa8b3, 0x426d, { 0x9c, 0x17, 0x76, 0xda, 0xb1, 0xe1, 0xe1, 0x4a } }
 
 namespace mozilla {
 namespace dom {
 
 class PBrowserParent;

--- a/dom/plugins/base/nsNPAPIPluginInstance.h
+++ b/dom/plugins/base/nsNPAPIPluginInstance.h
@@ -11,32 +11,31 @@
 #include "nsPIDOMWindow.h"
 #include "nsITimer.h"
 #include "nsIPluginTagInfo.h"
 #include "nsIURI.h"
 #include "nsIChannel.h"
 #include "nsInterfaceHashtable.h"
 #include "nsHashKeys.h"
 #include <prinrval.h>
+#include "js/TypeDecls.h"
 #ifdef MOZ_WIDGET_ANDROID
 #include "nsAutoPtr.h"
 #include "nsIRunnable.h"
 #include "GLContext.h"
 #include "nsSurfaceTexture.h"
 #include "AndroidBridge.h"
 #include <map>
 class PluginEventRunnable;
 class SharedPluginTexture;
 #endif
 
 #include "mozilla/TimeStamp.h"
 #include "mozilla/PluginLibrary.h"
 
-class JSObject;
-
 class nsPluginStreamListenerPeer; // browser-initiated stream class
 class nsNPAPIPluginStreamListener; // plugin-initiated stream class
 class nsIPluginInstanceOwner;
 class nsIOutputStream;
 class nsPluginInstanceOwner;
 
 #if defined(OS_WIN)
 const NPDrawingModel kDefaultDrawingModel = NPDrawingModelSyncWin;

--- a/dom/promise/Promise.h
+++ b/dom/promise/Promise.h
@@ -10,18 +10,17 @@
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "nsCycleCollectionParticipant.h"
 #include "mozilla/dom/PromiseBinding.h"
 #include "nsWrapperCache.h"
 #include "nsAutoPtr.h"
 #include "nsPIDOMWindow.h"
-
-struct JSContext;
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 namespace dom {
 
 class PromiseInit;
 class PromiseCallback;
 class AnyCallback;
 class PromiseResolver;

--- a/dom/promise/PromiseResolver.h
+++ b/dom/promise/PromiseResolver.h
@@ -7,18 +7,17 @@
 #ifndef mozilla_dom_PromiseResolver_h
 #define mozilla_dom_PromiseResolver_h
 
 #include "mozilla/dom/Promise.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
-
-struct JSContext;
+#include "js/TypeDecls.h"
 
 namespace mozilla {
 namespace dom {
 
 class PromiseResolver MOZ_FINAL : public nsWrapperCache
 {
   friend class PromiseResolverTask;
   friend class WrapperPromiseCallback;

--- a/dom/src/geolocation/nsGeoPosition.h
+++ b/dom/src/geolocation/nsGeoPosition.h
@@ -9,18 +9,17 @@
 #include "nsAutoPtr.h"
 #include "nsIDOMGeoPositionCoords.h"
 #include "nsIDOMGeoPosition.h"
 #include "nsString.h"
 #include "mozilla/Attributes.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
 #include "mozilla/dom/Nullable.h"
-
-struct JSContext;
+#include "js/TypeDecls.h"
 
 ////////////////////////////////////////////////////
 // nsGeoPositionCoords
 ////////////////////////////////////////////////////
 
 /**
  * Simple object that holds a single point in space.
  */

--- a/dom/workers/test/Makefile.in
+++ b/dom/workers/test/Makefile.in
@@ -88,32 +88,38 @@ MOCHITEST_FILES = \
   test_workersDisabled.html \
   workersDisabled_worker.js \
   test_xhr_implicit_cancel.html \
   xhr_implicit_cancel_worker.js \
   test_xhr_parameters.html \
   test_xhr_parameters.js \
   test_xhr_system.html \
   test_xhr_system.js \
-  test_xhr_timeout.html \
   test_blobConstructor.html \
   test_csp.html \
   test_csp.js \
   test_csp.html^headers^ \
   csp_worker.js \
   test_transferable.html \
   transferable_worker.js \
   test_errorwarning.html \
   errorwarning_worker.js \
   test_contentWorker.html \
   content_worker.js \
   test_url.html \
   url_worker.js \
   $(NULL)
 
+# Bug 842386 - Disabled on OSX due to intermittent failures.
+ifneq ($(OS_ARCH), Darwin)
+MOCHITEST_FILES += \
+  test_xhr_timeout.html \
+  $(NULL)
+endif
+
 MOCHITEST_CHROME_FILES = \
   test_chromeWorker.xul \
   test_chromeWorkerJSM.xul \
   test_extension.xul \
   test_extensionBootstrap.xul \
   test_file.xul \
   test_fileSlice.xul \
   test_fileBlobPosting.xul \

--- a/embedding/components/windowwatcher/src/nsWindowWatcher.h
+++ b/embedding/components/windowwatcher/src/nsWindowWatcher.h
@@ -12,27 +12,26 @@
 
 #include "nsCOMPtr.h"
 #include "mozilla/Mutex.h"
 #include "nsIWindowCreator.h" // for stupid compilers
 #include "nsIWindowWatcher.h"
 #include "nsIPromptFactory.h"
 #include "nsPIWindowWatcher.h"
 #include "nsTArray.h"
+#include "js/TypeDecls.h"
 
 class  nsIURI;
 class  nsIDocShellTreeItem;
 class  nsIDocShellTreeOwner;
 class  nsIWebBrowserChrome;
 class  nsString;
 class  nsWatcherWindowEnumerator;
 class  nsIScriptContext;
 class  nsPromptService;
-struct JSContext;
-class JSObject;
 struct nsWatcherWindowEntry;
 struct SizeSpec;
 
 class nsWindowWatcher :
       public nsIWindowWatcher,
       public nsPIWindowWatcher,
       public nsIPromptFactory
 {

--- a/gfx/layers/Layers.cpp
+++ b/gfx/layers/Layers.cpp
@@ -708,16 +708,131 @@ ContainerLayer::ContainerLayer(LayerMana
     mMayHaveReadbackChild(false)
 {
   mContentFlags = 0; // Clear NO_TEXT, NO_TEXT_OVER_TRANSPARENT
 }
 
 ContainerLayer::~ContainerLayer() {}
 
 void
+ContainerLayer::InsertAfter(Layer* aChild, Layer* aAfter)
+{
+  NS_ASSERTION(aChild->Manager() == Manager(),
+               "Child has wrong manager");
+  NS_ASSERTION(!aChild->GetParent(),
+               "aChild already in the tree");
+  NS_ASSERTION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
+               "aChild already has siblings?");
+  NS_ASSERTION(!aAfter ||
+               (aAfter->Manager() == Manager() &&
+                aAfter->GetParent() == this),
+               "aAfter is not our child");
+
+  aChild->SetParent(this);
+  if (aAfter == mLastChild) {
+    mLastChild = aChild;
+  }
+  if (!aAfter) {
+    aChild->SetNextSibling(mFirstChild);
+    if (mFirstChild) {
+      mFirstChild->SetPrevSibling(aChild);
+    }
+    mFirstChild = aChild;
+    NS_ADDREF(aChild);
+    DidInsertChild(aChild);
+    return;
+  }
+
+  Layer* next = aAfter->GetNextSibling();
+  aChild->SetNextSibling(next);
+  aChild->SetPrevSibling(aAfter);
+  if (next) {
+    next->SetPrevSibling(aChild);
+  }
+  aAfter->SetNextSibling(aChild);
+  NS_ADDREF(aChild);
+  DidInsertChild(aChild);
+}
+
+void
+ContainerLayer::RemoveChild(Layer *aChild)
+{
+  NS_ASSERTION(aChild->Manager() == Manager(),
+               "Child has wrong manager");
+  NS_ASSERTION(aChild->GetParent() == this,
+               "aChild not our child");
+
+  Layer* prev = aChild->GetPrevSibling();
+  Layer* next = aChild->GetNextSibling();
+  if (prev) {
+    prev->SetNextSibling(next);
+  } else {
+    this->mFirstChild = next;
+  }
+  if (next) {
+    next->SetPrevSibling(prev);
+  } else {
+    this->mLastChild = prev;
+  }
+
+  aChild->SetNextSibling(nullptr);
+  aChild->SetPrevSibling(nullptr);
+  aChild->SetParent(nullptr);
+
+  this->DidRemoveChild(aChild);
+  NS_RELEASE(aChild);
+}
+
+
+void
+ContainerLayer::RepositionChild(Layer* aChild, Layer* aAfter)
+{
+  NS_ASSERTION(aChild->Manager() == Manager(),
+               "Child has wrong manager");
+  NS_ASSERTION(aChild->GetParent() == this,
+               "aChild not our child");
+  NS_ASSERTION(!aAfter ||
+               (aAfter->Manager() == Manager() &&
+                aAfter->GetParent() == this),
+               "aAfter is not our child");
+
+  Layer* prev = aChild->GetPrevSibling();
+  Layer* next = aChild->GetNextSibling();
+  if (prev == aAfter) {
+    // aChild is already in the correct position, nothing to do.
+    return;
+  }
+  if (prev) {
+    prev->SetNextSibling(next);
+  }
+  if (next) {
+    next->SetPrevSibling(prev);
+  }
+  if (!aAfter) {
+    aChild->SetPrevSibling(nullptr);
+    aChild->SetNextSibling(mFirstChild);
+    if (mFirstChild) {
+      mFirstChild->SetPrevSibling(aChild);
+    }
+    mFirstChild = aChild;
+    return;
+  }
+
+  Layer* afterNext = aAfter->GetNextSibling();
+  if (afterNext) {
+    afterNext->SetPrevSibling(aChild);
+  } else {
+    mLastChild = aChild;
+  }
+  aAfter->SetNextSibling(aChild);
+  aChild->SetPrevSibling(aAfter);
+  aChild->SetNextSibling(afterNext);
+}
+
+void
 ContainerLayer::FillSpecificAttributes(SpecificLayerAttributes& aAttrs)
 {
   aAttrs = ContainerLayerAttributes(GetFrameMetrics(), mPreXScale, mPreYScale,
                                     mInheritedXScale, mInheritedYScale);
 }
 
 bool
 ContainerLayer::HasMultipleChildren()
@@ -822,16 +937,26 @@ ContainerLayer::DefaultComputeEffectiveT
 void
 ContainerLayer::ComputeEffectiveTransformsForChildren(const gfx3DMatrix& aTransformToSurface)
 {
   for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
     l->ComputeEffectiveTransforms(aTransformToSurface);
   }
 }
 
+/* static */ bool
+ContainerLayer::HasOpaqueAncestorLayer(Layer* aLayer)
+{
+  for (Layer* l = aLayer->GetParent(); l; l = l->GetParent()) {
+    if (l->GetContentFlags() & Layer::CONTENT_OPAQUE)
+      return true;
+  }
+  return false;
+}
+
 void
 ContainerLayer::DidRemoveChild(Layer* aLayer)
 {
   ThebesLayer* tl = aLayer->AsThebesLayer();
   if (tl && tl->UsedForReadback()) {
     for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
       if (l->GetType() == TYPE_READBACK) {
         static_cast<ReadbackLayer*>(l)->NotifyThebesLayerRemoved(tl);

--- a/gfx/layers/Layers.h
+++ b/gfx/layers/Layers.h
@@ -1406,31 +1406,31 @@ public:
 
   /**
    * CONSTRUCTION PHASE ONLY
    * Insert aChild into the child list of this container. aChild must
    * not be currently in any child list or the root for the layer manager.
    * If aAfter is non-null, it must be a child of this container and
    * we insert after that layer. If it's null we insert at the start.
    */
-  virtual void InsertAfter(Layer* aChild, Layer* aAfter) = 0;
+  virtual void InsertAfter(Layer* aChild, Layer* aAfter);
   /**
    * CONSTRUCTION PHASE ONLY
    * Remove aChild from the child list of this container. aChild must
    * be a child of this container.
    */
-  virtual void RemoveChild(Layer* aChild) = 0;
+  virtual void RemoveChild(Layer* aChild);
   /**
    * CONSTRUCTION PHASE ONLY
    * Reposition aChild from the child list of this container. aChild must
    * be a child of this container.
    * If aAfter is non-null, it must be a child of this container and we
    * reposition after that layer. If it's null, we reposition at the start.
    */
-  virtual void RepositionChild(Layer* aChild, Layer* aAfter) = 0;
+  virtual void RepositionChild(Layer* aChild, Layer* aAfter);
 
   /**
    * CONSTRUCTION PHASE ONLY
    * Set the (sub)document metrics used to render the Layer subtree
    * rooted at this.
    */
   void SetFrameMetrics(const FrameMetrics& aFrameMetrics)
   {
@@ -1525,16 +1525,18 @@ public:
    * Returns true if this container supports children with component alpha.
    * Should only be called while painting a child of this layer.
    */
   bool SupportsComponentAlphaChildren() { return mSupportsComponentAlphaChildren; }
 
 protected:
   friend class ReadbackProcessor;
 
+  static bool HasOpaqueAncestorLayer(Layer* aLayer);
+
   void DidInsertChild(Layer* aLayer);
   void DidRemoveChild(Layer* aLayer);
 
   ContainerLayer(LayerManager* aManager, void* aImplData);
 
   /**
    * A default implementation of ComputeEffectiveTransforms for use by OpenGL
    * and D3D.

--- a/gfx/layers/basic/BasicContainerLayer.cpp
+++ b/gfx/layers/basic/BasicContainerLayer.cpp
@@ -10,31 +10,70 @@
 #include "basic/BasicLayers.h"          // for BasicLayerManager
 #include "mozilla/gfx/BaseRect.h"       // for BaseRect
 #include "mozilla/mozalloc.h"           // for operator new
 #include "nsAutoPtr.h"                  // for nsRefPtr
 #include "nsCOMPtr.h"                   // for already_AddRefed
 #include "nsISupportsImpl.h"            // for Layer::AddRef, etc
 #include "nsPoint.h"                    // for nsIntPoint
 #include "nsRect.h"                     // for nsIntRect
+#include "gfx3DMatrix.h"                // for gfx3DMatrix
+#include "gfxMatrix.h"                  // for gfxMatrix
+#include "nsRegion.h"                   // for nsIntRegion
 
 using namespace mozilla::gfx;
 
 namespace mozilla {
 namespace layers {
 
 BasicContainerLayer::~BasicContainerLayer()
 {
   while (mFirstChild) {
-    ContainerRemoveChild(mFirstChild, this);
+    ContainerLayer::RemoveChild(mFirstChild);
   }
 
   MOZ_COUNT_DTOR(BasicContainerLayer);
 }
 
+void
+BasicContainerLayer::ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface)
+{
+  // We push groups for container layers if we need to, which always
+  // are aligned in device space, so it doesn't really matter how we snap
+  // containers.
+  gfxMatrix residual;
+  gfx3DMatrix idealTransform = GetLocalTransform()*aTransformToSurface;
+  idealTransform.ProjectTo2D();
+
+  if (!idealTransform.CanDraw2D()) {
+    mEffectiveTransform = idealTransform;
+    ComputeEffectiveTransformsForChildren(gfx3DMatrix());
+    ComputeEffectiveTransformForMaskLayer(gfx3DMatrix());
+    mUseIntermediateSurface = true;
+    return;
+  }
+
+  mEffectiveTransform = SnapTransformTranslation(idealTransform, &residual);
+  // We always pass the ideal matrix down to our children, so there is no
+  // need to apply any compensation using the residual from SnapTransformTranslation.
+  ComputeEffectiveTransformsForChildren(idealTransform);
+
+  ComputeEffectiveTransformForMaskLayer(aTransformToSurface);
+
+  /* If we have a single child, it can just inherit our opacity,
+   * otherwise we need a PushGroup and we need to mark ourselves as using
+   * an intermediate surface so our children don't inherit our opacity
+   * via GetEffectiveOpacity.
+   * Having a mask layer always forces our own push group
+   */
+  mUseIntermediateSurface =
+    GetMaskLayer() || (GetEffectiveOpacity() != 1.0 &&
+                       HasMultipleChildren());
+}
+
 bool
 BasicContainerLayer::ChildrenPartitionVisibleRegion(const nsIntRect& aInRect)
 {
   gfxMatrix transform;
   if (!GetEffectiveTransform().CanDraw2D(&transform) ||
       transform.HasNonIntegerTranslation())
     return false;
 

--- a/gfx/layers/basic/BasicContainerLayer.h
+++ b/gfx/layers/basic/BasicContainerLayer.h
@@ -4,191 +4,25 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_BASICCONTAINERLAYER_H
 #define GFX_BASICCONTAINERLAYER_H
 
 #include "BasicImplData.h"              // for BasicImplData
 #include "BasicLayers.h"                // for BasicLayerManager
 #include "Layers.h"                     // for Layer, ContainerLayer
-#include "gfx3DMatrix.h"                // for gfx3DMatrix
-#include "gfxMatrix.h"                  // for gfxMatrix
 #include "nsDebug.h"                    // for NS_ASSERTION
 #include "nsISupportsUtils.h"           // for NS_ADDREF, NS_RELEASE
-#include "nsRegion.h"                   // for nsIntRegion
 #include "nsTraceRefcnt.h"              // for MOZ_COUNT_CTOR
 struct nsIntRect;
 
 namespace mozilla {
 namespace layers {
 
-template<class Container> void
-ContainerInsertAfter(Layer* aChild, Layer* aAfter, Container* aContainer)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(!aChild->GetParent(),
-               "aChild already in the tree");
-  NS_ASSERTION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
-               "aChild already has siblings?");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  aChild->SetParent(aContainer);
-  if (aAfter == aContainer->mLastChild) {
-    aContainer->mLastChild = aChild;
-  }
-  if (!aAfter) {
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    NS_ADDREF(aChild);
-    aContainer->DidInsertChild(aChild);
-    return;
-  }
-
-  Layer* next = aAfter->GetNextSibling();
-  aChild->SetNextSibling(next);
-  aChild->SetPrevSibling(aAfter);
-  if (next) {
-    next->SetPrevSibling(aChild);
-  }
-  aAfter->SetNextSibling(aChild);
-  NS_ADDREF(aChild);
-  aContainer->DidInsertChild(aChild);
-}
-
-template<class Container> void
-ContainerRemoveChild(Layer* aChild, Container* aContainer)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev) {
-    prev->SetNextSibling(next);
-  } else {
-    aContainer->mFirstChild = next;
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  } else {
-    aContainer->mLastChild = prev;
-  }
-
-  aChild->SetNextSibling(nullptr);
-  aChild->SetPrevSibling(nullptr);
-  aChild->SetParent(nullptr);
-
-  aContainer->DidRemoveChild(aChild);
-  NS_RELEASE(aChild);
-}
-
-template<class Container> void
-ContainerRepositionChild(Layer* aChild, Layer* aAfter, Container* aContainer)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev == aAfter) {
-    // aChild is already in the correct position, nothing to do.
-    return;
-  }
-  if (prev) {
-    prev->SetNextSibling(next);
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  }
-  if (!aAfter) {
-    aChild->SetPrevSibling(nullptr);
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    return;
-  }
-
-  Layer* afterNext = aAfter->GetNextSibling();
-  if (afterNext) {
-    afterNext->SetPrevSibling(aChild);
-  } else {
-    aContainer->mLastChild = aChild;
-  }
-  aAfter->SetNextSibling(aChild);
-  aChild->SetPrevSibling(aAfter);
-  aChild->SetNextSibling(afterNext);
-}
-
-template<class Container>
-static void
-ContainerComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface,
-                                    Container* aContainer)
-{
-  // We push groups for container layers if we need to, which always
-  // are aligned in device space, so it doesn't really matter how we snap
-  // containers.
-  gfxMatrix residual;
-  gfx3DMatrix idealTransform = aContainer->GetLocalTransform()*aTransformToSurface;
-  idealTransform.ProjectTo2D();
-
-  if (!idealTransform.CanDraw2D()) {
-    aContainer->mEffectiveTransform = idealTransform;
-    aContainer->ComputeEffectiveTransformsForChildren(gfx3DMatrix());
-    aContainer->ComputeEffectiveTransformForMaskLayer(gfx3DMatrix());
-    aContainer->mUseIntermediateSurface = true;
-    return;
-  }
-
-  aContainer->mEffectiveTransform =
-    aContainer->SnapTransformTranslation(idealTransform, &residual);
-  // We always pass the ideal matrix down to our children, so there is no
-  // need to apply any compensation using the residual from SnapTransformTranslation.
-  aContainer->ComputeEffectiveTransformsForChildren(idealTransform);
-
-  aContainer->ComputeEffectiveTransformForMaskLayer(aTransformToSurface);
-
-  /* If we have a single child, it can just inherit our opacity,
-   * otherwise we need a PushGroup and we need to mark ourselves as using
-   * an intermediate surface so our children don't inherit our opacity
-   * via GetEffectiveOpacity.
-   * Having a mask layer always forces our own push group
-   */
-  aContainer->mUseIntermediateSurface =
-    aContainer->GetMaskLayer() || (aContainer->GetEffectiveOpacity() != 1.0 &&
-                                   aContainer->HasMultipleChildren());
-}
-
 class BasicContainerLayer : public ContainerLayer, public BasicImplData {
-  template<class Container>
-  friend void ContainerInsertAfter(Layer* aChild, Layer* aAfter, Container* aContainer);
-  template<class Container>
-  friend void ContainerRemoveChild(Layer* aChild, Container* aContainer);
-  template<class Container>
-  friend void ContainerRepositionChild(Layer* aChild, Layer* aAfter, Container* aContainer);
-  template<class Container>
-  friend void ContainerComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface,
-                                                  Container* aContainer);
-
 public:
   BasicContainerLayer(BasicLayerManager* aManager) :
     ContainerLayer(aManager,
                    static_cast<BasicImplData*>(MOZ_THIS_IN_INITIALIZER_LIST()))
   {
     MOZ_COUNT_CTOR(BasicContainerLayer);
     mSupportsComponentAlphaChildren = true;
   }
@@ -199,37 +33,34 @@ public:
     NS_ASSERTION(BasicManager()->InConstruction(),
                  "Can only set properties in construction phase");
     ContainerLayer::SetVisibleRegion(aRegion);
   }
   virtual void InsertAfter(Layer* aChild, Layer* aAfter)
   {
     NS_ASSERTION(BasicManager()->InConstruction(),
                  "Can only set properties in construction phase");
-    ContainerInsertAfter(aChild, aAfter, this);
+    ContainerLayer::InsertAfter(aChild, aAfter);
   }
 
   virtual void RemoveChild(Layer* aChild)
   { 
     NS_ASSERTION(BasicManager()->InConstruction(),
                  "Can only set properties in construction phase");
-    ContainerRemoveChild(aChild, this);
+    ContainerLayer::RemoveChild(aChild);
   }
 
   virtual void RepositionChild(Layer* aChild, Layer* aAfter)
   {
     NS_ASSERTION(BasicManager()->InConstruction(),
                  "Can only set properties in construction phase");
-    ContainerRepositionChild(aChild, aAfter, this);
+    ContainerLayer::RepositionChild(aChild, aAfter);
   }
 
-  virtual void ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface)
-  {
-    ContainerComputeEffectiveTransforms(aTransformToSurface, this);
-  }
+  virtual void ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface);
 
   /**
    * Returns true when:
    * a) no (non-hidden) childrens' visible areas overlap in
    * (aInRect intersected with this layer's visible region).
    * b) the (non-hidden) childrens' visible areas cover
    * (aInRect intersected with this layer's visible region).
    * c) this layer and all (non-hidden) children have transforms that are translations

--- a/gfx/layers/client/ClientContainerLayer.h
+++ b/gfx/layers/client/ClientContainerLayer.h
@@ -18,162 +18,31 @@
 #include "nsTArray.h"                   // for nsAutoTArray
 #include "nsTraceRefcnt.h"              // for MOZ_COUNT_CTOR, etc
 
 namespace mozilla {
 namespace layers {
 
 class ShadowableLayer;
 
-template<class Container> void
-ContainerInsertAfter(Layer* aChild, Layer* aAfter, Container* aContainer)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(!aChild->GetParent(),
-               "aChild already in the tree");
-  NS_ASSERTION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
-               "aChild already has siblings?");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  aChild->SetParent(aContainer);
-  if (aAfter == aContainer->mLastChild) {
-    aContainer->mLastChild = aChild;
-  }
-  if (!aAfter) {
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    NS_ADDREF(aChild);
-    aContainer->DidInsertChild(aChild);
-    return;
-  }
-
-  Layer* next = aAfter->GetNextSibling();
-  aChild->SetNextSibling(next);
-  aChild->SetPrevSibling(aAfter);
-  if (next) {
-    next->SetPrevSibling(aChild);
-  }
-  aAfter->SetNextSibling(aChild);
-  NS_ADDREF(aChild);
-  aContainer->DidInsertChild(aChild);
-}
-
-template<class Container> void
-ContainerRemoveChild(Layer* aChild, Container* aContainer)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev) {
-    prev->SetNextSibling(next);
-  } else {
-    aContainer->mFirstChild = next;
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  } else {
-    aContainer->mLastChild = prev;
-  }
-
-  aChild->SetNextSibling(nullptr);
-  aChild->SetPrevSibling(nullptr);
-  aChild->SetParent(nullptr);
-
-  aContainer->DidRemoveChild(aChild);
-  NS_RELEASE(aChild);
-}
-
-template<class Container> void
-ContainerRepositionChild(Layer* aChild, Layer* aAfter, Container* aContainer)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev == aAfter) {
-    // aChild is already in the correct position, nothing to do.
-    return;
-  }
-  if (prev) {
-    prev->SetNextSibling(next);
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  }
-  if (!aAfter) {
-    aChild->SetPrevSibling(nullptr);
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    return;
-  }
-
-  Layer* afterNext = aAfter->GetNextSibling();
-  if (afterNext) {
-    afterNext->SetPrevSibling(aChild);
-  } else {
-    aContainer->mLastChild = aChild;
-  }
-  aAfter->SetNextSibling(aChild);
-  aChild->SetPrevSibling(aAfter);
-  aChild->SetNextSibling(afterNext);
-}
-
-static bool
-HasOpaqueAncestorLayer(Layer* aLayer)
-{
-  for (Layer* l = aLayer->GetParent(); l; l = l->GetParent()) {
-    if (l->GetContentFlags() & Layer::CONTENT_OPAQUE)
-      return true;
-  }
-  return false;
-}
-
 class ClientContainerLayer : public ContainerLayer,
                              public ClientLayer
 {
-  template<class Container>
-  friend void ContainerInsertAfter(Layer* aChild, Layer* aAfter, Container* aContainer);
-  template<class Container>
-  friend void ContainerRemoveChild(Layer* aChild, Container* aContainer);
-  template<class Container>
-  friend void ContainerRepositionChild(Layer* aChild, Layer* aAfter, Container* aContainer);
-
 public:
   ClientContainerLayer(ClientLayerManager* aManager) :
     ContainerLayer(aManager,
                    static_cast<ClientLayer*>(MOZ_THIS_IN_INITIALIZER_LIST()))
   {
     MOZ_COUNT_CTOR(ClientContainerLayer);
     mSupportsComponentAlphaChildren = true;
   }
   virtual ~ClientContainerLayer()
   {
     while (mFirstChild) {
-      ContainerRemoveChild(mFirstChild, this);
+      ContainerLayer::RemoveChild(mFirstChild);
     }
 
     MOZ_COUNT_DTOR(ClientContainerLayer);
   }
 
   virtual void RenderLayer()
   {
     if (GetMaskLayer()) {
@@ -214,43 +83,43 @@ public:
   }
 
   virtual void SetVisibleRegion(const nsIntRegion& aRegion)
   {
     NS_ASSERTION(ClientManager()->InConstruction(),
                  "Can only set properties in construction phase");
     ContainerLayer::SetVisibleRegion(aRegion);
   }
-  virtual void InsertAfter(Layer* aChild, Layer* aAfter)
+  virtual void InsertAfter(Layer* aChild, Layer* aAfter) MOZ_OVERRIDE
   {
     NS_ASSERTION(ClientManager()->InConstruction(),
                  "Can only set properties in construction phase");
     ClientManager()->InsertAfter(ClientManager()->Hold(this),
                                  ClientManager()->Hold(aChild),
                                  aAfter ? ClientManager()->Hold(aAfter) : nullptr);
-    ContainerInsertAfter(aChild, aAfter, this);
+    ContainerLayer::InsertAfter(aChild, aAfter);
   }
 
-  virtual void RemoveChild(Layer* aChild)
+  virtual void RemoveChild(Layer* aChild) MOZ_OVERRIDE
   { 
     NS_ASSERTION(ClientManager()->InConstruction(),
                  "Can only set properties in construction phase");
     ClientManager()->RemoveChild(ClientManager()->Hold(this),
                                  ClientManager()->Hold(aChild));
-    ContainerRemoveChild(aChild, this);
+    ContainerLayer::RemoveChild(aChild);
   }
 
-  virtual void RepositionChild(Layer* aChild, Layer* aAfter)
+  virtual void RepositionChild(Layer* aChild, Layer* aAfter) MOZ_OVERRIDE
   {
     NS_ASSERTION(ClientManager()->InConstruction(),
                  "Can only set properties in construction phase");
     ClientManager()->RepositionChild(ClientManager()->Hold(this),
                                      ClientManager()->Hold(aChild),
                                      aAfter ? ClientManager()->Hold(aAfter) : nullptr);
-    ContainerRepositionChild(aChild, aAfter, this);
+    ContainerLayer::RepositionChild(aChild, aAfter);
   }
   
   virtual Layer* AsLayer() { return this; }
   virtual ShadowableLayer* AsShadowableLayer() { return this; }
 
   virtual void ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface)
   {
     DefaultComputeEffectiveTransforms(aTransformToSurface);

--- a/gfx/layers/composite/ContainerLayerComposite.cpp
+++ b/gfx/layers/composite/ContainerLayerComposite.cpp
@@ -111,16 +111,21 @@ ContainerRender(ContainerT* aContainer,
     }
 
     surfaceRect -= gfx::IntPoint(aOffset.x, aOffset.y);
     if (surfaceCopyNeeded) {
       surface = compositor->CreateRenderTargetFromSource(surfaceRect, previousTarget);
     } else {
       surface = compositor->CreateRenderTarget(surfaceRect, mode);
     }
+
+    if (!surface) {
+      return;
+    }
+
     compositor->SetRenderTarget(surface);
     childOffset.x = visibleRect.x;
     childOffset.y = visibleRect.y;
   } else {
     surface = previousTarget;
     aContainer->mSupportsComponentAlphaChildren = (aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE) ||
       (aContainer->GetParent() && aContainer->GetParent()->SupportsComponentAlphaChildren());
   }
@@ -212,85 +217,16 @@ ContainerLayerComposite::~ContainerLayer
   // *ContainerLayerComposite::Destroy(), or Disconnect() will trigger
   // cleanup of our resources.
   while (mFirstChild) {
     RemoveChild(mFirstChild);
   }
 }
 
 void
-ContainerLayerComposite::InsertAfter(Layer* aChild, Layer* aAfter)
-{
-  NS_ASSERTION(aChild->Manager() == Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(!aChild->GetParent(),
-               "aChild already in the tree");
-  NS_ASSERTION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
-               "aChild already has siblings?");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == Manager() &&
-                aAfter->GetParent() == this),
-               "aAfter is not our child");
-
-  aChild->SetParent(this);
-  if (aAfter == mLastChild) {
-    mLastChild = aChild;
-  }
-  if (!aAfter) {
-    aChild->SetNextSibling(mFirstChild);
-    if (mFirstChild) {
-      mFirstChild->SetPrevSibling(aChild);
-    }
-    mFirstChild = aChild;
-    NS_ADDREF(aChild);
-    DidInsertChild(aChild);
-    return;
-  }
-
-  Layer* next = aAfter->GetNextSibling();
-  aChild->SetNextSibling(next);
-  aChild->SetPrevSibling(aAfter);
-  if (next) {
-    next->SetPrevSibling(aChild);
-  }
-  aAfter->SetNextSibling(aChild);
-  NS_ADDREF(aChild);
-  DidInsertChild(aChild);
-}
-
-void
-ContainerLayerComposite::RemoveChild(Layer *aChild)
-{
-  NS_ASSERTION(aChild->Manager() == Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == this,
-               "aChild not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev) {
-    prev->SetNextSibling(next);
-  } else {
-    this->mFirstChild = next;
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  } else {
-    this->mLastChild = prev;
-  }
-
-  aChild->SetNextSibling(nullptr);
-  aChild->SetPrevSibling(nullptr);
-  aChild->SetParent(nullptr);
-
-  this->DidRemoveChild(aChild);
-  NS_RELEASE(aChild);
-}
-
-void
 ContainerLayerComposite::Destroy()
 {
   if (!mDestroyed) {
     while (mFirstChild) {
       static_cast<LayerComposite*>(GetFirstChild()->ImplData())->Destroy();
       RemoveChild(mFirstChild);
     }
     mDestroyed = true;
@@ -302,61 +238,16 @@ ContainerLayerComposite::GetFirstChildCo
 {
   if (!mFirstChild) {
     return nullptr;
    }
   return static_cast<LayerComposite*>(mFirstChild->ImplData());
 }
 
 void
-ContainerLayerComposite::RepositionChild(Layer* aChild, Layer* aAfter)
-{
-  NS_ASSERTION(aChild->Manager() == Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == this,
-               "aChild not our child");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == Manager() &&
-                aAfter->GetParent() == this),
-               "aAfter is not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev == aAfter) {
-    // aChild is already in the correct position, nothing to do.
-    return;
-  }
-  if (prev) {
-    prev->SetNextSibling(next);
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  }
-  if (!aAfter) {
-    aChild->SetPrevSibling(nullptr);
-    aChild->SetNextSibling(mFirstChild);
-    if (mFirstChild) {
-      mFirstChild->SetPrevSibling(aChild);
-    }
-    mFirstChild = aChild;
-    return;
-  }
-
-  Layer* afterNext = aAfter->GetNextSibling();
-  if (afterNext) {
-    afterNext->SetPrevSibling(aChild);
-  } else {
-    mLastChild = aChild;
-  }
-  aAfter->SetNextSibling(aChild);
-  aChild->SetPrevSibling(aAfter);
-  aChild->SetNextSibling(afterNext);
-}
-
-void
 ContainerLayerComposite::RenderLayer(const nsIntPoint& aOffset,
                                      const nsIntRect& aClipRect)
 {
   ContainerRender(this, aOffset, mCompositeManager, aClipRect);
 }
 
 void
 ContainerLayerComposite::CleanupResources()

--- a/gfx/layers/composite/ContainerLayerComposite.h
+++ b/gfx/layers/composite/ContainerLayerComposite.h
@@ -28,22 +28,16 @@ class ContainerLayerComposite : public C
                               const nsIntPoint& aOffset,
                               LayerManagerComposite* aManager,
                               const nsIntRect& aClipRect);
 public:
   ContainerLayerComposite(LayerManagerComposite *aManager);
 
   ~ContainerLayerComposite();
 
-  void InsertAfter(Layer* aChild, Layer* aAfter);
-
-  void RemoveChild(Layer* aChild);
-
-  void RepositionChild(Layer* aChild, Layer* aAfter);
-
   // LayerComposite Implementation
   virtual Layer* GetLayer() MOZ_OVERRIDE { return this; }
 
   virtual void Destroy() MOZ_OVERRIDE;
 
   LayerComposite* GetFirstChildComposite();
 
   virtual void RenderLayer(const nsIntPoint& aOffset,

--- a/gfx/layers/d3d10/ContainerLayerD3D10.cpp
+++ b/gfx/layers/d3d10/ContainerLayerD3D10.cpp
@@ -23,150 +23,16 @@ ContainerLayerD3D10::ContainerLayerD3D10
 }
 
 ContainerLayerD3D10::~ContainerLayerD3D10()
 {
   while (mFirstChild) {
     RemoveChild(mFirstChild);
   }
 }
-template<class Container>
-static void
-ContainerInsertAfter(Container* aContainer, Layer* aChild, Layer* aAfter)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(!aChild->GetParent(),
-               "aChild already in the tree");
-  NS_ASSERTION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
-               "aChild already has siblings?");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  aChild->SetParent(aContainer);
-  if (aAfter == aContainer->mLastChild) {
-    aContainer->mLastChild = aChild;
-  }
-  if (!aAfter) {
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    NS_ADDREF(aChild);
-    aContainer->DidInsertChild(aChild);
-    return;
-  }
-
-  Layer* next = aAfter->GetNextSibling();
-  aChild->SetNextSibling(next);
-  aChild->SetPrevSibling(aAfter);
-  if (next) {
-    next->SetPrevSibling(aChild);
-  }
-  aAfter->SetNextSibling(aChild);
-  NS_ADDREF(aChild);
-  aContainer->DidInsertChild(aChild);
-}
-
-template<class Container>
-static void
-ContainerRemoveChild(Container* aContainer, Layer* aChild)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev) {
-    prev->SetNextSibling(next);
-  } else {
-    aContainer->mFirstChild = next;
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  } else {
-    aContainer->mLastChild = prev;
-  }
-
-  aChild->SetNextSibling(nullptr);
-  aChild->SetPrevSibling(nullptr);
-  aChild->SetParent(nullptr);
-
-  aContainer->DidRemoveChild(aChild);
-  NS_RELEASE(aChild);
-}
-
-template<class Container>
-static void
-ContainerRepositionChild(Container* aContainer, Layer* aChild, Layer* aAfter)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev == aAfter) {
-    // aChild is already in the correct position, nothing to do.
-    return;
-  }
-  if (prev) {
-    prev->SetNextSibling(next);
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  }
-  if (!aAfter) {
-    aChild->SetPrevSibling(nullptr);
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    return;
-  }
-
-  Layer* afterNext = aAfter->GetNextSibling();
-  if (afterNext) {
-    afterNext->SetPrevSibling(aChild);
-  } else {
-    aContainer->mLastChild = aChild;
-  }
-  aAfter->SetNextSibling(aChild);
-  aChild->SetPrevSibling(aAfter);
-  aChild->SetNextSibling(afterNext);
-}
-
-void
-ContainerLayerD3D10::InsertAfter(Layer* aChild, Layer* aAfter)
-{
-  ContainerInsertAfter(this, aChild, aAfter);
-}
-
-void
-ContainerLayerD3D10::RemoveChild(Layer *aChild)
-{
-  ContainerRemoveChild(this, aChild);
-}
-
-void
-ContainerLayerD3D10::RepositionChild(Layer* aChild, Layer* aAfter)
-{
-  ContainerRepositionChild(this, aChild, aAfter);
-}
 
 Layer*
 ContainerLayerD3D10::GetLayer()
 {
   return this;
 }
 
 LayerD3D10*

--- a/gfx/layers/d3d10/ContainerLayerD3D10.h
+++ b/gfx/layers/d3d10/ContainerLayerD3D10.h
@@ -6,45 +6,25 @@
 #ifndef GFX_CONTAINERLAYERD3D10_H
 #define GFX_CONTAINERLAYERD3D10_H
 
 #include "LayerManagerD3D10.h"
 
 namespace mozilla {
 namespace layers {
 
-template<class Container>
-static void ContainerInsertAfter(Container* aContainer, Layer* aChild, Layer* aAfter);
-template<class Container>
-static void ContainerRemoveChild(Container* aContainer, Layer* aChild);
-template<class Container>
-static void ContainerRepositionChild(Container* aContainer, Layer* aChild, Layer* aAfter);
-
 class ContainerLayerD3D10 : public ContainerLayer,
                             public LayerD3D10
 {
-  template<class Container>
-  friend void ContainerInsertAfter(Container* aContainer, Layer* aChild, Layer* aAfter);
-  template<class Container>
-  friend void ContainerRemoveChild(Container* aContainer, Layer* aChild);
-  template<class Container>
-  friend void ContainerRepositionChild(Container* aContainer, Layer* aChild, Layer* aAfter);
 public:
   ContainerLayerD3D10(LayerManagerD3D10 *aManager);
   ~ContainerLayerD3D10();
 
   nsIntRect GetVisibleRect() { return mVisibleRegion.GetBounds(); }
 
-  /* ContainerLayer implementation */
-  virtual void InsertAfter(Layer* aChild, Layer* aAfter);
-
-  virtual void RemoveChild(Layer* aChild);
-
-  virtual void RepositionChild(Layer* aChild, Layer* aAfter);
-
   /* LayerD3D10 implementation */
   virtual Layer* GetLayer();
 
   virtual LayerD3D10* GetFirstChildD3D10();
 
   virtual void RenderLayer();
   virtual void Validate();
 

--- a/gfx/layers/d3d11/CompositorD3D11.cpp
+++ b/gfx/layers/d3d11/CompositorD3D11.cpp
@@ -366,16 +366,20 @@ TemporaryRef<CompositingRenderTarget>
 CompositorD3D11::CreateRenderTarget(const gfx::IntRect& aRect,
                                     SurfaceInitMode aInit)
 {
   CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, aRect.width, aRect.height, 1, 1,
                              D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET);
 
   RefPtr<ID3D11Texture2D> texture;
   mDevice->CreateTexture2D(&desc, nullptr, byRef(texture));
+  NS_ASSERTION(texture, "Could not create texture");
+  if (!texture) {
+    return nullptr;
+  }
 
   RefPtr<CompositingRenderTargetD3D11> rt = new CompositingRenderTargetD3D11(texture);
   rt->SetSize(IntSize(aRect.width, aRect.height));
 
   if (aInit == INIT_MODE_CLEAR) {
     FLOAT clear[] = { 0, 0, 0, 0 };
     mContext->ClearRenderTargetView(rt->mRTView, clear);
   }
@@ -388,16 +392,20 @@ CompositorD3D11::CreateRenderTargetFromS
                                               const CompositingRenderTarget* aSource)
 {
   CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM,
                              aRect.width, aRect.height, 1, 1,
                              D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET);
 
   RefPtr<ID3D11Texture2D> texture;
   mDevice->CreateTexture2D(&desc, nullptr, byRef(texture));
+  NS_ASSERTION(texture, "Could not create texture");
+  if (!texture) {
+    return nullptr;
+  }
 
   if (aSource) {
     const CompositingRenderTargetD3D11* sourceD3D11 =
       static_cast<const CompositingRenderTargetD3D11*>(aSource);
 
     D3D11_BOX srcBox;
     srcBox.left = aRect.x;
     srcBox.top = aRect.y;

--- a/gfx/layers/d3d9/ContainerLayerD3D9.cpp
+++ b/gfx/layers/d3d9/ContainerLayerD3D9.cpp
@@ -7,270 +7,152 @@
 #include "gfxUtils.h"
 #include "nsRect.h"
 #include "ThebesLayerD3D9.h"
 #include "ReadbackProcessor.h"
 
 namespace mozilla {
 namespace layers {
 
-template<class Container>
-static void
-ContainerInsertAfter(Container* aContainer, Layer* aChild, Layer* aAfter)
+ContainerLayerD3D9::ContainerLayerD3D9(LayerManagerD3D9 *aManager)
+  : ContainerLayer(aManager, nullptr)
+  , LayerD3D9(aManager)
 {
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(!aChild->GetParent(),
-               "aChild already in the tree");
-  NS_ASSERTION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
-               "aChild already has siblings?");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  aChild->SetParent(aContainer);
-  if (aAfter == aContainer->mLastChild) {
-    aContainer->mLastChild = aChild;
-  }
-  if (!aAfter) {
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    NS_ADDREF(aChild);
-    aContainer->DidInsertChild(aChild);
-    return;
-  }
-
-  Layer* next = aAfter->GetNextSibling();
-  aChild->SetNextSibling(next);
-  aChild->SetPrevSibling(aAfter);
-  if (next) {
-    next->SetPrevSibling(aChild);
-  }
-  aAfter->SetNextSibling(aChild);
-  NS_ADDREF(aChild);
-  aContainer->DidInsertChild(aChild);
+  mImplData = static_cast<LayerD3D9*>(this);
 }
 
-template<class Container>
-static void
-ContainerRemoveChild(Container* aContainer, Layer* aChild)
+ContainerLayerD3D9::~ContainerLayerD3D9()
 {
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev) {
-    prev->SetNextSibling(next);
-  } else {
-    aContainer->mFirstChild = next;
+  while (mFirstChild) {
+    RemoveChild(mFirstChild);
   }
-  if (next) {
-    next->SetPrevSibling(prev);
-  } else {
-    aContainer->mLastChild = prev;
-  }
-
-  aChild->SetNextSibling(nullptr);
-  aChild->SetPrevSibling(nullptr);
-  aChild->SetParent(nullptr);
-
-  aContainer->DidRemoveChild(aChild);
-  NS_RELEASE(aChild);
 }
 
-template<class Container>
-static void
-ContainerRepositionChild(Container* aContainer, Layer* aChild, Layer* aAfter)
+Layer*
+ContainerLayerD3D9::GetLayer()
 {
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev == aAfter) {
-    // aChild is already in the correct position, nothing to do.
-    return;
-  }
-  if (prev) {
-    prev->SetNextSibling(next);
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  }
-  if (!aAfter) {
-    aChild->SetPrevSibling(nullptr);
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    return;
-  }
-
-  Layer* afterNext = aAfter->GetNextSibling();
-  if (afterNext) {
-    afterNext->SetPrevSibling(aChild);
-  } else {
-    aContainer->mLastChild = aChild;
-  }
-  aAfter->SetNextSibling(aChild);
-  aChild->SetPrevSibling(aAfter);
-  aChild->SetNextSibling(afterNext);
+  return this;
 }
 
-static inline LayerD3D9*
-GetNextSibling(LayerD3D9* aLayer)
+LayerD3D9*
+ContainerLayerD3D9::GetFirstChildD3D9()
 {
-   Layer* layer = aLayer->GetLayer()->GetNextSibling();
-   return layer ? static_cast<LayerD3D9*>(layer->
-                                         ImplData())
-                 : nullptr;
+  if (!mFirstChild) {
+    return nullptr;
+  }
+  return static_cast<LayerD3D9*>(mFirstChild->ImplData());
 }
 
-static bool
-HasOpaqueAncestorLayer(Layer* aLayer)
-{
-  for (Layer* l = aLayer->GetParent(); l; l = l->GetParent()) {
-    if (l->GetContentFlags() & Layer::CONTENT_OPAQUE)
-      return true;
-  }
-  return false;
-}
-
-static inline LayerD3D9*
-GetNextSiblingD3D9(LayerD3D9* aLayer)
-{
-   Layer* layer = aLayer->GetLayer()->GetNextSibling();
-   return layer ? static_cast<LayerD3D9*>(layer->
-                                          ImplData())
-                 : nullptr;
-}
-
-template<class Container>
-static void
-ContainerRender(Container* aContainer,
-                LayerManagerD3D9* aManager)
+void
+ContainerLayerD3D9::RenderLayer()
 {
   nsRefPtr<IDirect3DSurface9> previousRenderTarget;
   nsRefPtr<IDirect3DTexture9> renderTexture;
   float previousRenderTargetOffset[4];
   float renderTargetOffset[] = { 0, 0, 0, 0 };
   float oldViewMatrix[4][4];
 
   RECT containerD3D9ClipRect; 
-  aManager->device()->GetScissorRect(&containerD3D9ClipRect);
+  device()->GetScissorRect(&containerD3D9ClipRect);
   // Convert scissor to an nsIntRect. RECT's are exclusive on the bottom and
   // right values.
   nsIntRect oldScissor(containerD3D9ClipRect.left, 
                        containerD3D9ClipRect.top,
                        containerD3D9ClipRect.right - containerD3D9ClipRect.left,
                        containerD3D9ClipRect.bottom - containerD3D9ClipRect.top);
 
   ReadbackProcessor readback;
-  readback.BuildUpdates(aContainer);
+  readback.BuildUpdates(this);
 
-  nsIntRect visibleRect = aContainer->GetEffectiveVisibleRegion().GetBounds();
-  bool useIntermediate = aContainer->UseIntermediateSurface();
+  nsIntRect visibleRect = GetEffectiveVisibleRegion().GetBounds();
+  bool useIntermediate = UseIntermediateSurface();
 
-  aContainer->mSupportsComponentAlphaChildren = false;
+  mSupportsComponentAlphaChildren = false;
   if (useIntermediate) {
     nsRefPtr<IDirect3DSurface9> renderSurface;
-    if (!aManager->CompositingDisabled()) {
-      aManager->device()->GetRenderTarget(0, getter_AddRefs(previousRenderTarget));
-      HRESULT hr = aManager->device()->CreateTexture(visibleRect.width, visibleRect.height, 1,
-                                                     D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8,
-                                                     D3DPOOL_DEFAULT, getter_AddRefs(renderTexture),
-                                                     nullptr);
+    if (!mD3DManager->CompositingDisabled()) {
+      device()->GetRenderTarget(0, getter_AddRefs(previousRenderTarget));
+      HRESULT hr = device()->CreateTexture(visibleRect.width, visibleRect.height, 1,
+                                           D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8,
+                                           D3DPOOL_DEFAULT, getter_AddRefs(renderTexture),
+                                           nullptr);
       if (FAILED(hr)) {
-        aManager->ReportFailure(NS_LITERAL_CSTRING("ContainerLayerD3D9::ContainerRender(): Failed to create texture"),
+        ReportFailure(NS_LITERAL_CSTRING("ContainerLayerD3D9::ContainerRender(): Failed to create texture"),
                                 hr);
         return;
       }
 
       nsRefPtr<IDirect3DSurface9> renderSurface;
       renderTexture->GetSurfaceLevel(0, getter_AddRefs(renderSurface));
-      aManager->device()->SetRenderTarget(0, renderSurface);
+      device()->SetRenderTarget(0, renderSurface);
     }
 
-    if (aContainer->mVisibleRegion.GetNumRects() == 1 && 
-        (aContainer->GetContentFlags() & aContainer->CONTENT_OPAQUE)) {
+    if (mVisibleRegion.GetNumRects() == 1 && 
+        (GetContentFlags() & CONTENT_OPAQUE)) {
       // don't need a background, we're going to paint all opaque stuff
-      aContainer->mSupportsComponentAlphaChildren = true;
+      mSupportsComponentAlphaChildren = true;
     } else {
-      const gfx3DMatrix& transform3D = aContainer->GetEffectiveTransform();
+      const gfx3DMatrix& transform3D = GetEffectiveTransform();
       gfxMatrix transform;
       // If we have an opaque ancestor layer, then we can be sure that
       // all the pixels we draw into are either opaque already or will be
       // covered by something opaque. Otherwise copying up the background is
       // not safe.
       HRESULT hr = E_FAIL;
-      if (HasOpaqueAncestorLayer(aContainer) &&
+      if (HasOpaqueAncestorLayer(this) &&
           transform3D.Is2D(&transform) && !transform.HasNonIntegerTranslation()) {
         // Copy background up from below
         RECT dest = { 0, 0, visibleRect.width, visibleRect.height };
         RECT src = dest;
         ::OffsetRect(&src,
                      visibleRect.x + int32_t(transform.x0),
                      visibleRect.y + int32_t(transform.y0));
-        if (!aManager->CompositingDisabled()) {
-          hr = aManager->device()->
+        if (!mD3DManager->CompositingDisabled()) {
+          hr = device()->
             StretchRect(previousRenderTarget, &src, renderSurface, &dest, D3DTEXF_NONE);
         }
       }
       if (hr == S_OK) {
-        aContainer->mSupportsComponentAlphaChildren = true;
-      } else if (!aManager->CompositingDisabled()) {
-        aManager->device()->
+        mSupportsComponentAlphaChildren = true;
+      } else if (!mD3DManager->CompositingDisabled()) {
+        device()->
           Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 0), 0, 0);
       }
     }
 
-    aManager->device()->
+    device()->
       GetVertexShaderConstantF(CBvRenderTargetOffset, previousRenderTargetOffset, 1);
     renderTargetOffset[0] = (float)visibleRect.x;
     renderTargetOffset[1] = (float)visibleRect.y;
-    aManager->device()->
+    device()->
       SetVertexShaderConstantF(CBvRenderTargetOffset, renderTargetOffset, 1);
 
     gfx3DMatrix viewMatrix;
     /*
      * Matrix to transform to viewport space ( <-1.0, 1.0> topleft,
      * <1.0, -1.0> bottomright)
      */
     viewMatrix._11 = 2.0f / visibleRect.width;
     viewMatrix._22 = -2.0f / visibleRect.height;
     viewMatrix._41 = -1.0f;
     viewMatrix._42 = 1.0f;
 
-    aManager->device()->
+    device()->
       GetVertexShaderConstantF(CBmProjection, &oldViewMatrix[0][0], 4);
-    aManager->device()->
+    device()->
       SetVertexShaderConstantF(CBmProjection, &viewMatrix._11, 4);
   } else {
-    aContainer->mSupportsComponentAlphaChildren = 
-        (aContainer->GetContentFlags() & aContainer->CONTENT_OPAQUE) ||
-        (aContainer->mParent && 
-         aContainer->mParent->SupportsComponentAlphaChildren());
+    mSupportsComponentAlphaChildren = 
+        (GetContentFlags() & CONTENT_OPAQUE) ||
+        (mParent && 
+         mParent->SupportsComponentAlphaChildren());
   }
 
   nsAutoTArray<Layer*, 12> children;
-  aContainer->SortChildrenBy3DZOrder(children);
+  SortChildrenBy3DZOrder(children);
 
   /*
    * Render this container's contents.
    */
   for (uint32_t i = 0; i < children.Length(); i++) {
     LayerD3D9* layerToRender = static_cast<LayerD3D9*>(children.ElementAt(i)->ImplData());
 
     if (layerToRender->GetLayer()->GetEffectiveVisibleRegion().IsEmpty()) {
@@ -283,102 +165,48 @@ ContainerRender(Container* aContainer,
       continue;
     }
 
     RECT d3drect;
     d3drect.left = scissorRect.x;
     d3drect.top = scissorRect.y;
     d3drect.right = scissorRect.x + scissorRect.width;
     d3drect.bottom = scissorRect.y + scissorRect.height;
-    aManager->device()->SetScissorRect(&d3drect);
+    device()->SetScissorRect(&d3drect);
 
-    if (layerToRender->GetLayer()->GetType() == aContainer->TYPE_THEBES) {
+    if (layerToRender->GetLayer()->GetType() == TYPE_THEBES) {
       static_cast<ThebesLayerD3D9*>(layerToRender)->RenderThebesLayer(&readback);
     } else {
       layerToRender->RenderLayer();
     }
   }
     
-  if (useIntermediate && !aManager->CompositingDisabled()) {
-    aManager->device()->SetRenderTarget(0, previousRenderTarget);
-    aManager->device()->SetVertexShaderConstantF(CBvRenderTargetOffset, previousRenderTargetOffset, 1);
-    aManager->device()->SetVertexShaderConstantF(CBmProjection, &oldViewMatrix[0][0], 4);
+  if (useIntermediate && !mD3DManager->CompositingDisabled()) {
+    device()->SetRenderTarget(0, previousRenderTarget);
+    device()->SetVertexShaderConstantF(CBvRenderTargetOffset, previousRenderTargetOffset, 1);
+    device()->SetVertexShaderConstantF(CBmProjection, &oldViewMatrix[0][0], 4);
 
-    aManager->device()->SetVertexShaderConstantF(CBvLayerQuad,
+    device()->SetVertexShaderConstantF(CBvLayerQuad,
                                        ShaderConstantRect(visibleRect.x,
                                                           visibleRect.y,
                                                           visibleRect.width,
                                                           visibleRect.height),
                                        1);
 
-    aContainer->SetShaderTransformAndOpacity();
-    aManager->SetShaderMode(DeviceManagerD3D9::RGBALAYER,
-                            aContainer->GetMaskLayer(),
-                            aContainer->GetTransform().CanDraw2D());
-
-    aManager->device()->SetTexture(0, renderTexture);
-    aManager->device()->SetScissorRect(&containerD3D9ClipRect);
-    aManager->device()->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
-  } else {
-    aManager->device()->SetScissorRect(&containerD3D9ClipRect);
-  }
-}
-
-
-ContainerLayerD3D9::ContainerLayerD3D9(LayerManagerD3D9 *aManager)
-  : ContainerLayer(aManager, nullptr)
-  , LayerD3D9(aManager)
-{
-  mImplData = static_cast<LayerD3D9*>(this);
-}
-
-ContainerLayerD3D9::~ContainerLayerD3D9()
-{
-  while (mFirstChild) {
-    RemoveChild(mFirstChild);
-  }
-}
+    SetShaderTransformAndOpacity();
+    mD3DManager->SetShaderMode(DeviceManagerD3D9::RGBALAYER,
+                               GetMaskLayer(),
+                               GetTransform().CanDraw2D());
 
-void
-ContainerLayerD3D9::InsertAfter(Layer* aChild, Layer* aAfter)
-{
-  ContainerInsertAfter(this, aChild, aAfter);
-}
-
-void
-ContainerLayerD3D9::RemoveChild(Layer *aChild)
-{
-  ContainerRemoveChild(this, aChild);
-}
-
-void
-ContainerLayerD3D9::RepositionChild(Layer* aChild, Layer* aAfter)
-{
-  ContainerRepositionChild(this, aChild, aAfter);
-}
-
-Layer*
-ContainerLayerD3D9::GetLayer()
-{
-  return this;
-}
-
-LayerD3D9*
-ContainerLayerD3D9::GetFirstChildD3D9()
-{
-  if (!mFirstChild) {
-    return nullptr;
+    device()->SetTexture(0, renderTexture);
+    device()->SetScissorRect(&containerD3D9ClipRect);
+    device()->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
+  } else {
+    device()->SetScissorRect(&containerD3D9ClipRect);
   }
-  return static_cast<LayerD3D9*>(mFirstChild->ImplData());
-}
-
-void
-ContainerLayerD3D9::RenderLayer()
-{
-  ContainerRender(this, mD3DManager);
 }
 
 void
 ContainerLayerD3D9::LayerManagerDestroyed()
 {
   while (mFirstChild) {
     GetFirstChildD3D9()->LayerManagerDestroyed();
     RemoveChild(mFirstChild);

--- a/gfx/layers/d3d9/ContainerLayerD3D9.h
+++ b/gfx/layers/d3d9/ContainerLayerD3D9.h
@@ -7,50 +7,25 @@
 #define GFX_CONTAINERLAYERD3D9_H
 
 #include "Layers.h"
 #include "LayerManagerD3D9.h"
 
 namespace mozilla {
 namespace layers {
   
-template<class Container>
-static void ContainerInsertAfter(Container* aContainer, Layer* aChild, Layer* aAfter);
-template<class Container>
-static void ContainerRemoveChild(Container* aContainer, Layer* aChild);
-template<class Container>
-static void ContainerRepositionChild(Container* aContainer, Layer* aChild, Layer* aAfter);
-template<class Container>
-static void ContainerRender(Container* aContainer, LayerManagerD3D9* aManager);
-
 class ContainerLayerD3D9 : public ContainerLayer,
                            public LayerD3D9
 {
-  template<class Container>
-  friend void ContainerInsertAfter(Container* aContainer, Layer* aChild, Layer* aAfter);
-  template<class Container>
-  friend void ContainerRemoveChild(Container* aContainer, Layer* aChild);
-  template<class Container>
-  friend void ContainerRepositionChild(Container* aContainer, Layer* aChild, Layer* aAfter);
-  template<class Container>
-  friend void ContainerRender(Container* aContainer, LayerManagerD3D9* aManager);
-
 public:
   ContainerLayerD3D9(LayerManagerD3D9 *aManager);
   ~ContainerLayerD3D9();
 
   nsIntRect GetVisibleRect() { return mVisibleRegion.GetBounds(); }
 
-  /* ContainerLayer implementation */
-  virtual void InsertAfter(Layer* aChild, Layer* aAfter);
-
-  virtual void RemoveChild(Layer* aChild);
-
-  virtual void RepositionChild(Layer* aChild, Layer* aAfter);
-
   /* LayerD3D9 implementation */
   Layer* GetLayer();
 
   LayerD3D9* GetFirstChildD3D9();
 
   bool IsEmpty();
 
   void RenderLayer();

--- a/gfx/layers/opengl/ContainerLayerOGL.cpp
+++ b/gfx/layers/opengl/ContainerLayerOGL.cpp
@@ -23,403 +23,234 @@
 #include "nsTArray.h"                   // for nsAutoTArray
 #include "LayerManagerOGL.h"            // for LayerManagerOGL, LayerOGL, etc
 #include "LayerManagerOGLProgram.h"     // for ShaderProgramOGL
 class gfxImageSurface;
 
 namespace mozilla {
 namespace layers {
 
-template<class Container>
-static void
-ContainerInsertAfter(Container* aContainer, Layer* aChild, Layer* aAfter)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(!aChild->GetParent(),
-               "aChild already in the tree");
-  NS_ASSERTION(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
-               "aChild already has siblings?");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  aChild->SetParent(aContainer);
-  if (aAfter == aContainer->mLastChild) {
-    aContainer->mLastChild = aChild;
-  }
-  if (!aAfter) {
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    NS_ADDREF(aChild);
-    aContainer->DidInsertChild(aChild);
-    return;
-  }
-
-  Layer* next = aAfter->GetNextSibling();
-  aChild->SetNextSibling(next);
-  aChild->SetPrevSibling(aAfter);
-  if (next) {
-    next->SetPrevSibling(aChild);
-  }
-  aAfter->SetNextSibling(aChild);
-  NS_ADDREF(aChild);
-  aContainer->DidInsertChild(aChild);
-}
-
-template<class Container>
-static void
-ContainerRemoveChild(Container* aContainer, Layer* aChild)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev) {
-    prev->SetNextSibling(next);
-  } else {
-    aContainer->mFirstChild = next;
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  } else {
-    aContainer->mLastChild = prev;
-  }
-
-  aChild->SetNextSibling(nullptr);
-  aChild->SetPrevSibling(nullptr);
-  aChild->SetParent(nullptr);
-
-  aContainer->DidRemoveChild(aChild);
-  NS_RELEASE(aChild);
-}
-
-template<class Container>
-static void
-ContainerRepositionChild(Container* aContainer, Layer* aChild, Layer* aAfter)
-{
-  NS_ASSERTION(aChild->Manager() == aContainer->Manager(),
-               "Child has wrong manager");
-  NS_ASSERTION(aChild->GetParent() == aContainer,
-               "aChild not our child");
-  NS_ASSERTION(!aAfter ||
-               (aAfter->Manager() == aContainer->Manager() &&
-                aAfter->GetParent() == aContainer),
-               "aAfter is not our child");
-
-  Layer* prev = aChild->GetPrevSibling();
-  Layer* next = aChild->GetNextSibling();
-  if (prev == aAfter) {
-    // aChild is already in the correct position, nothing to do.
-    return;
-  }
-  if (prev) {
-    prev->SetNextSibling(next);
-  }
-  if (next) {
-    next->SetPrevSibling(prev);
-  }
-  if (!aAfter) {
-    aChild->SetPrevSibling(nullptr);
-    aChild->SetNextSibling(aContainer->mFirstChild);
-    if (aContainer->mFirstChild) {
-      aContainer->mFirstChild->SetPrevSibling(aChild);
-    }
-    aContainer->mFirstChild = aChild;
-    return;
-  }
-
-  Layer* afterNext = aAfter->GetNextSibling();
-  if (afterNext) {
-    afterNext->SetPrevSibling(aChild);
-  } else {
-    aContainer->mLastChild = aChild;
-  }
-  aAfter->SetNextSibling(aChild);
-  aChild->SetPrevSibling(aAfter);
-  aChild->SetNextSibling(afterNext);
-}
-
-template<class Container>
-static void
-ContainerDestroy(Container* aContainer)
- {
-  if (!aContainer->mDestroyed) {
-    while (aContainer->mFirstChild) {
-      aContainer->GetFirstChildOGL()->Destroy();
-      aContainer->RemoveChild(aContainer->mFirstChild);
-    }
-    aContainer->mDestroyed = true;
-  }
-}
-
-template<class Container>
-static void
-ContainerCleanupResources(Container* aContainer)
-{
-  for (Layer* l = aContainer->GetFirstChild(); l; l = l->GetNextSibling()) {
-    LayerOGL* layerToRender = static_cast<LayerOGL*>(l->ImplData());
-    layerToRender->CleanupResources();
-  }
-}
-
 static inline LayerOGL*
 GetNextSibling(LayerOGL* aLayer)
 {
    Layer* layer = aLayer->GetLayer()->GetNextSibling();
    return layer ? static_cast<LayerOGL*>(layer->
                                          ImplData())
                  : nullptr;
 }
 
-static bool
-HasOpaqueAncestorLayer(Layer* aLayer)
-{
-  for (Layer* l = aLayer->GetParent(); l; l = l->GetParent()) {
-    if (l->GetContentFlags() & Layer::CONTENT_OPAQUE)
-      return true;
-  }
-  return false;
-}
-
-template<class Container>
-static void
-ContainerRender(Container* aContainer,
-                int aPreviousFrameBuffer,
-                const nsIntPoint& aOffset,
-                LayerManagerOGL* aManager)
-{
-  /**
-   * Setup our temporary texture for rendering the contents of this container.
-   */
-  GLuint containerSurface;
-  GLuint frameBuffer;
-
-  nsIntPoint childOffset(aOffset);
-  nsIntRect visibleRect = aContainer->GetEffectiveVisibleRegion().GetBounds();
-
-  nsIntRect cachedScissor = aContainer->gl()->ScissorRect();
-  aContainer->gl()->PushScissorRect();
-  aContainer->mSupportsComponentAlphaChildren = false;
-
-  float opacity = aContainer->GetEffectiveOpacity();
-  const gfx3DMatrix& transform = aContainer->GetEffectiveTransform();
-  bool needsFramebuffer = aContainer->UseIntermediateSurface();
-  if (needsFramebuffer) {
-    nsIntRect framebufferRect = visibleRect;
-    // we're about to create a framebuffer backed by textures to use as an intermediate
-    // surface. What to do if its size (as given by framebufferRect) would exceed the
-    // maximum texture size supported by the GL? The present code chooses the compromise
-    // of just clamping the framebuffer's size to the max supported size.
-    // This gives us a lower resolution rendering of the intermediate surface (children layers).
-    // See bug 827170 for a discussion.
-    GLint maxTexSize;
-    aContainer->gl()->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, &maxTexSize);
-    framebufferRect.width = std::min(framebufferRect.width, maxTexSize);
-    framebufferRect.height = std::min(framebufferRect.height, maxTexSize);
-
-    LayerManagerOGL::InitMode mode = LayerManagerOGL::InitModeClear;
-    if (aContainer->GetEffectiveVisibleRegion().GetNumRects() == 1 && 
-        (aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE))
-    {
-      // don't need a background, we're going to paint all opaque stuff
-      aContainer->mSupportsComponentAlphaChildren = true;
-      mode = LayerManagerOGL::InitModeNone;
-    } else {
-      const gfx3DMatrix& transform3D = aContainer->GetEffectiveTransform();
-      gfxMatrix transform;
-      // If we have an opaque ancestor layer, then we can be sure that
-      // all the pixels we draw into are either opaque already or will be
-      // covered by something opaque. Otherwise copying up the background is
-      // not safe.
-      if (HasOpaqueAncestorLayer(aContainer) &&
-          transform3D.Is2D(&transform) && !transform.HasNonIntegerTranslation()) {
-        mode = gfxPlatform::ComponentAlphaEnabled() ?
-          LayerManagerOGL::InitModeCopy :
-          LayerManagerOGL::InitModeClear;
-        framebufferRect.x += transform.x0;
-        framebufferRect.y += transform.y0;
-        aContainer->mSupportsComponentAlphaChildren = gfxPlatform::ComponentAlphaEnabled();
-      }
-    }
-
-    aContainer->gl()->PushViewportRect();
-    framebufferRect -= childOffset;
-    if (!aManager->CompositingDisabled()) {
-      if (!aManager->CreateFBOWithTexture(framebufferRect,
-                                          mode,
-                                          aPreviousFrameBuffer,
-                                          &frameBuffer,
-                                          &containerSurface)) {
-        aContainer->gl()->PopViewportRect();
-        aContainer->gl()->PopScissorRect();
-        aContainer->gl()->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, aPreviousFrameBuffer);
-        return;
-      }
-    }
-    childOffset.x = visibleRect.x;
-    childOffset.y = visibleRect.y;
-  } else {
-    frameBuffer = aPreviousFrameBuffer;
-    aContainer->mSupportsComponentAlphaChildren = (aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE) ||
-      (aContainer->GetParent() && aContainer->GetParent()->SupportsComponentAlphaChildren());
-  }
-
-  nsAutoTArray<Layer*, 12> children;
-  aContainer->SortChildrenBy3DZOrder(children);
-
-  /**
-   * Render this container's contents.
-   */
-  for (uint32_t i = 0; i < children.Length(); i++) {
-    LayerOGL* layerToRender = static_cast<LayerOGL*>(children.ElementAt(i)->ImplData());
-
-    if (layerToRender->GetLayer()->GetEffectiveVisibleRegion().IsEmpty()) {
-      continue;
-    }
-
-    nsIntRect scissorRect = layerToRender->GetLayer()->
-        CalculateScissorRect(cachedScissor, &aManager->GetWorldTransform());
-    if (scissorRect.IsEmpty()) {
-      continue;
-    }
-
-    aContainer->gl()->fScissor(scissorRect.x, 
-                               scissorRect.y, 
-                               scissorRect.width, 
-                               scissorRect.height);
-
-    layerToRender->RenderLayer(frameBuffer, childOffset);
-    aContainer->gl()->MakeCurrent();
-  }
-
-
-  if (needsFramebuffer) {
-    // Unbind the current framebuffer and rebind the previous one.
-#ifdef MOZ_DUMP_PAINTING
-    if (gfxUtils::sDumpPainting) {
-      nsRefPtr<gfxImageSurface> surf = 
-        aContainer->gl()->GetTexImage(containerSurface, true, aManager->GetFBOTextureFormat());
-
-      WriteSnapshotToDumpFile(aContainer, surf);
-    }
-#endif
-    
-    // Restore the viewport
-    aContainer->gl()->PopViewportRect();
-    nsIntRect viewport = aContainer->gl()->ViewportRect();
-    aManager->SetupPipeline(viewport.width, viewport.height,
-                            LayerManagerOGL::ApplyWorldTransform);
-    aContainer->gl()->PopScissorRect();
-
-    if (!aManager->CompositingDisabled()) {
-      aContainer->gl()->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, aPreviousFrameBuffer);
-      aContainer->gl()->fDeleteFramebuffers(1, &frameBuffer);
-
-      aContainer->gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
-
-      aContainer->gl()->fBindTexture(aManager->FBOTextureTarget(), containerSurface);
-
-      MaskType maskType = MaskNone;
-      if (aContainer->GetMaskLayer()) {
-        if (!aContainer->GetTransform().CanDraw2D()) {
-          maskType = Mask3d;
-        } else {
-          maskType = Mask2d;
-        }
-      }
-      ShaderProgramOGL *rgb =
-        aManager->GetFBOLayerProgram(maskType);
-
-      rgb->Activate();
-      rgb->SetLayerQuadRect(visibleRect);
-      rgb->SetLayerTransform(transform);
-      rgb->SetTextureTransform(gfx3DMatrix());
-      rgb->SetLayerOpacity(opacity);
-      rgb->SetRenderOffset(aOffset);
-      rgb->SetTextureUnit(0);
-      rgb->LoadMask(aContainer->GetMaskLayer());
-
-      if (rgb->GetTexCoordMultiplierUniformLocation() != -1) {
-        // 2DRect case, get the multiplier right for a sampler2DRect
-        rgb->SetTexCoordMultiplier(visibleRect.width, visibleRect.height);
-      }
-
-      // Drawing is always flipped, but when copying between surfaces we want to avoid
-      // this. Pass true for the flip parameter to introduce a second flip
-      // that cancels the other one out.
-      aManager->BindAndDrawQuad(rgb, true);
-
-      // Clean up resources.  This also unbinds the texture.
-      aContainer->gl()->fDeleteTextures(1, &containerSurface);
-    }
-  } else {
-    aContainer->gl()->PopScissorRect();
-  }
-}
-
-ContainerLayerOGL::ContainerLayerOGL(LayerManagerOGL *aManager)
-  : ContainerLayer(aManager, nullptr)
-  , LayerOGL(aManager)
+ContainerLayerOGL::ContainerLayerOGL(LayerManagerOGL *mOGLManager)
+  : ContainerLayer(mOGLManager, nullptr)
+  , LayerOGL(mOGLManager)
 {
   mImplData = static_cast<LayerOGL*>(this);
 }
 
 ContainerLayerOGL::~ContainerLayerOGL()
 {
   Destroy();
 }
 
 void
-ContainerLayerOGL::InsertAfter(Layer* aChild, Layer* aAfter)
-{
-  ContainerInsertAfter(this, aChild, aAfter);
-}
-
-void
-ContainerLayerOGL::RemoveChild(Layer *aChild)
-{
-  ContainerRemoveChild(this, aChild);
-}
-
-void
-ContainerLayerOGL::RepositionChild(Layer* aChild, Layer* aAfter)
-{
-  ContainerRepositionChild(this, aChild, aAfter);
-}
-
-void
 ContainerLayerOGL::Destroy()
 {
-  ContainerDestroy(this);
+  if (!mDestroyed) {
+    while (mFirstChild) {
+      GetFirstChildOGL()->Destroy();
+      RemoveChild(mFirstChild);
+    }
+    mDestroyed = true;
+  }
 }
 
 LayerOGL*
 ContainerLayerOGL::GetFirstChildOGL()
 {
   if (!mFirstChild) {
     return nullptr;
   }
   return static_cast<LayerOGL*>(mFirstChild->ImplData());
 }
 
 void
 ContainerLayerOGL::RenderLayer(int aPreviousFrameBuffer,
                                const nsIntPoint& aOffset)
 {
-  ContainerRender(this, aPreviousFrameBuffer, aOffset, mOGLManager);
+  /**
+   * Setup our temporary texture for rendering the contents of this container.
+   */
+  GLuint containerSurface;
+  GLuint frameBuffer;
+
+  nsIntPoint childOffset(aOffset);
+  nsIntRect visibleRect = GetEffectiveVisibleRegion().GetBounds();
+
+  nsIntRect cachedScissor = gl()->ScissorRect();
+  gl()->PushScissorRect();
+  mSupportsComponentAlphaChildren = false;
+
+  float opacity = GetEffectiveOpacity();
+  const gfx3DMatrix& transform = GetEffectiveTransform();
+  bool needsFramebuffer = UseIntermediateSurface();
+  if (needsFramebuffer) {
+    nsIntRect framebufferRect = visibleRect;
+    // we're about to create a framebuffer backed by textures to use as an intermediate
+    // surface. What to do if its size (as given by framebufferRect) would exceed the
+    // maximum texture size supported by the GL? The present code chooses the compromise
+    // of just clamping the framebuffer's size to the max supported size.
+    // This gives us a lower resolution rendering of the intermediate surface (children layers).
+    // See bug 827170 for a discussion.
+    GLint maxTexSize;
+    gl()->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, &maxTexSize);
+    framebufferRect.width = std::min(framebufferRect.width, maxTexSize);
+    framebufferRect.height = std::min(framebufferRect.height, maxTexSize);
+
+    LayerManagerOGL::InitMode mode = LayerManagerOGL::InitModeClear;
+    if (GetEffectiveVisibleRegion().GetNumRects() == 1 && 
+        (GetContentFlags() & Layer::CONTENT_OPAQUE))
+    {
+      // don't need a background, we're going to paint all opaque stuff
+      mSupportsComponentAlphaChildren = true;
+      mode = LayerManagerOGL::InitModeNone;
+    } else {
+      const gfx3DMatrix& transform3D = GetEffectiveTransform();
+      gfxMatrix transform;
+      // If we have an opaque ancestor layer, then we can be sure that
+      // all the pixels we draw into are either opaque already or will be
+      // covered by something opaque. Otherwise copying up the background is
+      // not safe.
+      if (HasOpaqueAncestorLayer(this) &&
+          transform3D.Is2D(&transform) && !transform.HasNonIntegerTranslation()) {
+        mode = gfxPlatform::ComponentAlphaEnabled() ?
+          LayerManagerOGL::InitModeCopy :
+          LayerManagerOGL::InitModeClear;
+        framebufferRect.x += transform.x0;
+        framebufferRect.y += transform.y0;
+        mSupportsComponentAlphaChildren = gfxPlatform::ComponentAlphaEnabled();
+      }
+    }
+
+    gl()->PushViewportRect();
+    framebufferRect -= childOffset;
+    if (!mOGLManager->CompositingDisabled()) {
+      if (!mOGLManager->CreateFBOWithTexture(framebufferRect,
+                                          mode,
+                                          aPreviousFrameBuffer,
+                                          &frameBuffer,
+                                          &containerSurface)) {
+        gl()->PopViewportRect();
+        gl()->PopScissorRect();
+        gl()->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, aPreviousFrameBuffer);
+        return;
+      }
+    }
+    childOffset.x = visibleRect.x;
+    childOffset.y = visibleRect.y;
+  } else {
+    frameBuffer = aPreviousFrameBuffer;
+    mSupportsComponentAlphaChildren = (GetContentFlags() & Layer::CONTENT_OPAQUE) ||
+      (GetParent() && GetParent()->SupportsComponentAlphaChildren());
+  }
+
+  nsAutoTArray<Layer*, 12> children;
+  SortChildrenBy3DZOrder(children);
+
+  /**
+   * Render this container's contents.
+   */
+  for (uint32_t i = 0; i < children.Length(); i++) {
+    LayerOGL* layerToRender = static_cast<LayerOGL*>(children.ElementAt(i)->ImplData());
+
+    if (layerToRender->GetLayer()->GetEffectiveVisibleRegion().IsEmpty()) {
+      continue;
+    }
+
+    nsIntRect scissorRect = layerToRender->GetLayer()->
+        CalculateScissorRect(cachedScissor, &mOGLManager->GetWorldTransform());
+    if (scissorRect.IsEmpty()) {
+      continue;
+    }
+
+    gl()->fScissor(scissorRect.x, 
+                               scissorRect.y, 
+                               scissorRect.width, 
+                               scissorRect.height);
+
+    layerToRender->RenderLayer(frameBuffer, childOffset);
+    gl()->MakeCurrent();
+  }
+
+
+  if (needsFramebuffer) {
+    // Unbind the current framebuffer and rebind the previous one.
+#ifdef MOZ_DUMP_PAINTING
+    if (gfxUtils::sDumpPainting) {
+      nsRefPtr<gfxImageSurface> surf = 
+        gl()->GetTexImage(containerSurface, true, mOGLManager->GetFBOTextureFormat());
+
+      WriteSnapshotToDumpFile(this, surf);
+    }
+#endif
+    
+    // Restore the viewport
+    gl()->PopViewportRect();
+    nsIntRect viewport = gl()->ViewportRect();
+    mOGLManager->SetupPipeline(viewport.width, viewport.height,
+                            LayerManagerOGL::ApplyWorldTransform);
+    gl()->PopScissorRect();
+
+    if (!mOGLManager->CompositingDisabled()) {
+      gl()->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, aPreviousFrameBuffer);
+      gl()->fDeleteFramebuffers(1, &frameBuffer);
+
+      gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
+
+      gl()->fBindTexture(mOGLManager->FBOTextureTarget(), containerSurface);
+
+      MaskType maskType = MaskNone;
+      if (GetMaskLayer()) {
+        if (!GetTransform().CanDraw2D()) {
+          maskType = Mask3d;
+        } else {
+          maskType = Mask2d;
+        }
+      }
+      ShaderProgramOGL *rgb =
+        mOGLManager->GetFBOLayerProgram(maskType);
+
+      rgb->Activate();
+      rgb->SetLayerQuadRect(visibleRect);
+      rgb->SetLayerTransform(transform);
+      rgb->SetTextureTransform(gfx3DMatrix());
+      rgb->SetLayerOpacity(opacity);
+      rgb->SetRenderOffset(aOffset);
+      rgb->SetTextureUnit(0);
+      rgb->LoadMask(GetMaskLayer());
+
+      if (rgb->GetTexCoordMultiplierUniformLocation() != -1) {
+        // 2DRect case, get the multiplier right for a sampler2DRect
+        rgb->SetTexCoordMultiplier(visibleRect.width, visibleRect.height);
+      }
+
+      // Drawing is always flipped, but when copying between surfaces we want to avoid
+      // this. Pass true for the flip parameter to introduce a second flip
+      // that cancels the other one out.
+      mOGLManager->BindAndDrawQuad(rgb, true);
+
+      // Clean up resources.  This also unbinds the texture.
+      gl()->fDeleteTextures(1, &containerSurface);
+    }
+  } else {
+    gl()->PopScissorRect();
+  }
 }
 
 void
 ContainerLayerOGL::CleanupResources()
 {
-  ContainerCleanupResources(this);
+  for (Layer* l = GetFirstChild(); l; l = l->GetNextSibling()) {
+    LayerOGL* layerToRender = static_cast<LayerOGL*>(l->ImplData());
+    layerToRender->CleanupResources();
+  }
 }
 
 } /* layers */
 } /* mozilla */