--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -1493,16 +1493,21 @@ pref("toolkit.telemetry.hybridContent.en
 pref("browser.ping-centre.telemetry", true);
 pref("browser.ping-centre.log", false);
 pref("browser.ping-centre.staging.endpoint", "https://onyx_tiles.stage.mozaws.net/v3/links/ping-centre");
 pref("browser.ping-centre.production.endpoint", "https://tiles.services.mozilla.com/v3/links/ping-centre");
 
 // Enable GMP support in the addon manager.
 pref("media.gmp-provider.enabled", true);
 
+// Enable blocking access to storage from tracking resources by default on Nightly
+#ifdef NIGHTLY_BUILD
+pref("network.cookie.cookieBehavior", 4 /* BEHAVIOR_REJECT_TRACKER */);
+#endif
+
 pref("browser.contentblocking.allowlist.storage.enabled", true);
 
 pref("browser.contentblocking.global-toggle.enabled", true);
 
 // Define a set of default features for the Content Blocking UI
 pref("browser.contentblocking.fastblock.ui.enabled", true);
 pref("browser.contentblocking.fastblock.control-center.ui.enabled", true);
 pref("browser.contentblocking.trackingprotection.ui.enabled", true);

--- a/browser/extensions/webcompat-reporter/content/WebCompatReporter.jsm
+++ b/browser/extensions/webcompat-reporter/content/WebCompatReporter.jsm
@@ -31,16 +31,25 @@ Object.defineProperty(details, "blockLis
   get() {
     let trackingTable = Services.prefs.getCharPref("urlclassifier.trackingTable");
     // If content-track-digest256 is in the tracking table,
     // the user has enabled the strict list.
     return trackingTable.includes("content") ? "strict" : "basic";
   },
 });
 
+Object.defineProperty(details, "hasTouchScreen", {
+  enumerable: true,
+  get() {
+    // return a boolean to indicate there's a touch screen detected or not
+    let gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
+    return gfxInfo.getInfo().ApzTouchInput == 1;
+  },
+});
+
 if (AppConstants.platform == "linux") {
   XPCOMUtils.defineLazyPreferenceGetter(details, "layers.acceleration.force-enabled", "layers.acceleration.force-enabled", false);
 }
 
 let WebCompatReporter = {
   get endpoint() {
     return Services.urlFormatter.formatURLPref(
       "extensions.webcompat-reporter.newIssueEndpoint");

--- a/build/moz.configure/node.configure
+++ b/build/moz.configure/node.configure
@@ -1,102 +1,60 @@
 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # 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/.
 
 option('--disable-nodejs',
        help='Require Node.js to build')
+option(env='NODEJS', nargs=1, help='Path to nodejs')
 
 
-@depends(host)
-@imports('os')
-@imports(_from='os', _import='environ')
-def node_toolchain_search_path(host):
-    # XXX partly copied from tooltool.py; should be hoisted somewhere central
-
-    # Also add in the location to which `mach bootstrap` or
-    # `mach artifact toolchain` installs clang.
-    mozbuild_state_dir = environ.get('MOZBUILD_STATE_PATH', os.path.expanduser(
-                                     os.path.join('~', '.mozbuild')))
-
-    if host.kernel == "WINNT":
-        mozbuild_node_path = os.path.join(mozbuild_state_dir, 'node')
-    else:
-        mozbuild_node_path = os.path.join(mozbuild_state_dir, 'node', 'bin')
-
-    # We still fallback to the PATH, since on OSes that don't have toolchain
-    # artifacts available to download, Node may be coming from $PATH.
-    path = [environ.get('PATH')]
-    updated_path = [mozbuild_node_path] + path
-
-    return updated_path
+@depends('--enable-nodejs', 'NODEJS')
+@checking('for nodejs',
+          callback=lambda x: '%s (%s)' % (x.path, x.str_version) if x else 'no')
+@imports(_from='mozbuild.nodeutil', _import='find_node_executable')
+@imports(_from='mozbuild.nodeutil', _import='NODE_MIN_VERSION')
+def nodejs(require, env_node):
+    node_exe = env_node[0] if env_node else None
 
-# "nodejs" is first in the tuple on the assumption that it's only likely to
-# exist on systems (probably linux distros) where there is a program in the path
-# called "node" that does something else.
-nodejs = check_prog('NODEJS', ('nodejs', 'node',),
-                    allow_missing=True, paths=node_toolchain_search_path,
-                    paths_have_priority=True)
-
-
-@depends_if(nodejs)
-@checking('for node.js version')
-@imports('os')
-@imports('re')
-@imports('subprocess')
-def nodejs_version(node):
-    env = dict(os.environ)
-    env[b'NODE_DISABLE_COLORS'] = b'1'
-
-    out = check_cmd_output(node, '--version', env=env)
-
-    match = re.search(r'v(.+)$', out)
-
-    if not match:
-        return None
-
-    return Version(match.group(1))
-
-
-@depends('--enable-nodejs', nodejs, nodejs_version)
-def nodejs_suitability(require, node, version):
-    MIN_NODE_VERSION = Version('8.11')
+    nodejs, version = find_node_executable(node_exe)
 
     MAYBE_FILE_A_BUG = '''
 
-If you believe this is a bug, <https://mzl.la/2vLbXAv> is a good way
-to file.  Executing `mach bootstrap --no-system-changes` should
-install a compatible version in ~/.mozbuild on most platforms.
-More details: <https://bit.ly/2BbyD1E>
-'''
+    Executing `mach bootstrap --no-system-changes` should
+    install a compatible version in ~/.mozbuild on most platforms.
+    If you believe this is a bug, <https://mzl.la/2vLbXAv> is a good way
+    to file.  More details: <https://bit.ly/2BbyD1E>
+    '''
 
-    if not node:
-        msg = ('could not find Node.js executable; ensure `node` or `nodejs` '
-               'is in PATH or set NODEJS in environment to point to an '
-               'executable.%s' % (MAYBE_FILE_A_BUG)
+    if not nodejs:
+        msg = ('could not find Node.js executable later than %s; ensure '
+               '`node` or `nodejs` is in PATH or set NODEJS in environment '
+               'to point to an executable.%s' % (NODE_MIN_VERSION, MAYBE_FILE_A_BUG)
                )
 
         if require:
             raise FatalCheckError(msg)
         else:
             log.warning(msg)
             log.warning('(This will become an error in the near future.)')
             return
 
     if not version:
-        msg = 'could not resolve Node.js version.%s' % (MAYBE_FILE_A_BUG)
-        if require:
-            raise FatalCheckError(msg)
-        else:
-            log.warning(msg)
-            log.warning('(This will become an error in the near future.)')
-            return
-
-    if version < MIN_NODE_VERSION:
-        msg = 'NODEJS must point to node %s or newer; %s found. %s' % (
-            MIN_NODE_VERSION, version, MAYBE_FILE_A_BUG)
+        msg = 'NODEJS must point to node %s or newer; found node location: %s. %s' % (
+            NODE_MIN_VERSION, nodejs, MAYBE_FILE_A_BUG)
 
         if require:
             raise FatalCheckError(msg)
         else:
             log.warning(msg)
+            return
+
+    return namespace(
+        path=nodejs,
+        version=version,
+        str_version='.'.join(str(v) for v in version),
+    )
+
+
+set_config('NODEJS', depends_if(nodejs)(lambda p: p.path))

--- a/config/rules.mk
+++ b/config/rules.mk
@@ -26,17 +26,17 @@ endif
 
 USE_AUTOTARGETS_MK = 1
 include $(MOZILLA_DIR)/config/makefiles/makeutils.mk
 
 ifdef REBUILD_CHECK
 REPORT_BUILD = $(info $(shell $(PYTHON) $(MOZILLA_DIR)/config/rebuild_check.py $@ $^))
 REPORT_BUILD_VERBOSE = $(REPORT_BUILD)
 else
-REPORT_BUILD = $(info $(notdir $@))
+REPORT_BUILD = $(info $(relativesrcdir)/$(notdir $@))
 
 ifdef BUILD_VERBOSE_LOG
 REPORT_BUILD_VERBOSE = $(REPORT_BUILD)
 else
 REPORT_BUILD_VERBOSE = $(call BUILDSTATUS,BUILD_VERBOSE $(relativesrcdir))
 endif
 
 endif

--- a/devtools/server/tests/mochitest/inspector-helpers.js
+++ b/devtools/server/tests/mochitest/inspector-helpers.js
@@ -4,18 +4,16 @@
    runNextTest */
 "use strict";
 
 const {require} = ChromeUtils.import("resource://devtools/shared/Loader.jsm", {});
 const {DebuggerClient} = require("devtools/shared/client/debugger-client");
 const {DebuggerServer} = require("devtools/server/main");
 
 const Services = require("Services");
-// promise is still used in tests using this helper
-const defer = require("devtools/shared/defer");
 const {DocumentWalker: _documentWalker} = require("devtools/server/actors/inspector/document-walker");
 
 // Always log packets when running tests.
 Services.prefs.setBoolPref("devtools.debugger.log", true);
 SimpleTest.registerCleanupFunction(function() {
   Services.prefs.clearUserPref("devtools.debugger.log");
 });
 
@@ -82,25 +80,25 @@ function attachURL(url, callback) {
       });
     }
   });
 
   return cleanup;
 }
 
 function promiseOnce(target, event) {
-  const deferred = defer();
-  target.on(event, (...args) => {
-    if (args.length === 1) {
-      deferred.resolve(args[0]);
-    } else {
-      deferred.resolve(args);
-    }
+  return new Promise(resolve => {
+    target.on(event, (...args) => {
+      if (args.length === 1) {
+        resolve(args[0]);
+      } else {
+        resolve(args);
+      }
+    });
   });
-  return deferred.promise;
 }
 
 function sortOwnershipChildren(children) {
   return children.sort((a, b) => a.name.localeCompare(b.name));
 }
 
 function serverOwnershipSubtree(walker, node) {
   const actor = walker._refMap.get(node);
@@ -166,47 +164,46 @@ function assertOwnershipTrees(walker) {
   is(JSON.stringify(clientTree, null, " "), JSON.stringify(serverTree, null, " "),
      "Server and client ownership trees should match.");
 
   return ownershipTreeSize(clientTree.root);
 }
 
 // Verify that an actorID is inaccessible both from the client library and the server.
 function checkMissing(client, actorID) {
-  let deferred = defer();
-  const front = client.getActor(actorID);
-  ok(!front, "Front shouldn't be accessible from the client for actorID: " + actorID);
+  return new Promise(resolve => {
+    const front = client.getActor(actorID);
+    ok(!front, "Front shouldn't be accessible from the client for actorID: " + actorID);
 
-  deferred = defer();
-  client.request({
-    to: actorID,
-    type: "request",
-  }, response => {
-    is(response.error, "noSuchActor", "node list actor should no longer be contactable.");
-    deferred.resolve(undefined);
+    client.request({
+      to: actorID,
+      type: "request",
+    }, response => {
+      is(response.error, "noSuchActor",
+        "node list actor should no longer be contactable.");
+      resolve(undefined);
+    });
   });
-  return deferred.promise;
 }
 
 // Verify that an actorID is accessible both from the client library and the server.
 function checkAvailable(client, actorID) {
-  let deferred = defer();
-  const front = client.getActor(actorID);
-  ok(front, "Front should be accessible from the client for actorID: " + actorID);
+  return new Promise(resolve => {
+    const front = client.getActor(actorID);
+    ok(front, "Front should be accessible from the client for actorID: " + actorID);
 
-  deferred = defer();
-  client.request({
-    to: actorID,
-    type: "garbageAvailableTest",
-  }, response => {
-    is(response.error, "unrecognizedPacketType",
-       "node list actor should be contactable.");
-    deferred.resolve(undefined);
+    client.request({
+      to: actorID,
+      type: "garbageAvailableTest",
+    }, response => {
+      is(response.error, "unrecognizedPacketType",
+        "node list actor should be contactable.");
+      resolve(undefined);
+    });
   });
-  return deferred.promise;
 }
 
 function promiseDone(currentPromise) {
   currentPromise.catch(err => {
     ok(false, "Promise failed: " + err);
     if (err.stack) {
       dump(err.stack);
     }
@@ -270,30 +267,30 @@ function assertFrameLoad(mutations) {
 // that mutation out of the list
 function assertChildList(mutations) {
   return assertAndStrip(mutations, "Should have had a frame load change.", isChildList);
 }
 
 // Load mutations aren't predictable, so keep accumulating mutations until
 // the one we're looking for shows up.
 function waitForMutation(walker, test, mutations = []) {
-  const deferred = defer();
-  for (const change of mutations) {
-    if (test(change)) {
-      deferred.resolve(mutations);
+  return new Promise(resolve => {
+    for (const change of mutations) {
+      if (test(change)) {
+        resolve(mutations);
+      }
     }
-  }
 
-  walker.once("mutations", newMutations => {
-    waitForMutation(walker, test, mutations.concat(newMutations)).then(finalMutations => {
-      deferred.resolve(finalMutations);
+    walker.once("mutations", newMutations => {
+      waitForMutation(walker, test, mutations.concat(newMutations))
+        .then(finalMutations => {
+          resolve(finalMutations);
+        });
     });
   });
-
-  return deferred.promise;
 }
 
 var _tests = [];
 function addTest(test) {
   _tests.push(test);
 }
 
 function addAsyncTest(generator) {

--- a/devtools/server/tests/mochitest/test_inspector-dead-nodes.html
+++ b/devtools/server/tests/mochitest/test_inspector-dead-nodes.html
@@ -19,21 +19,22 @@ window.onload = function() {
 };
 
 let gWalker = null;
 let gDoc = null;
 
 addAsyncTest(async function() {
   const url = document.getElementById("inspectorContent").href;
 
-  const def = defer();
-  attachURL(url, function(err, client, tab, doc) {
-    def.resolve({client, tab, doc});
+  const attachURLPromise = new Promise(resolve => {
+    attachURL(url, function(err, client, tab, doc) {
+      resolve({client, tab, doc});
+    });
   });
-  const {client, tab, doc} = await def.promise;
+  const {client, tab, doc} = await attachURLPromise;
   gDoc = doc;
 
   const {InspectorFront} = require("devtools/shared/fronts/inspector");
   const inspector = InspectorFront(client, tab);
   gWalker = await inspector.getWalker();
 
   runNextTest();
 });

--- a/devtools/shared/css/generated/properties-db.js
+++ b/devtools/shared/css/generated/properties-db.js
@@ -8209,16 +8209,53 @@ exports.CSS_PROPERTIES = {
       "inherit",
       "initial",
       "mandatory",
       "none",
       "proximity",
       "unset"
     ]
   },
+  "scrollbar-color": {
+    "isInherited": true,
+    "subproperties": [
+      "scrollbar-color"
+    ],
+    "supports": [
+      2
+    ],
+    "values": [
+      "COLOR",
+      "auto",
+      "currentColor",
+      "hsl",
+      "hsla",
+      "inherit",
+      "initial",
+      "rgb",
+      "rgba",
+      "transparent",
+      "unset"
+    ]
+  },
+  "scrollbar-width": {
+    "isInherited": false,
+    "subproperties": [
+      "scrollbar-width"
+    ],
+    "supports": [],
+    "values": [
+      "auto",
+      "inherit",
+      "initial",
+      "none",
+      "thin",
+      "unset"
+    ]
+  },
   "shape-image-threshold": {
     "isInherited": false,
     "subproperties": [
       "shape-image-threshold"
     ],
     "supports": [],
     "values": [
       "inherit",

--- a/dom/canvas/WebGLContextExtensions.cpp
+++ b/dom/canvas/WebGLContextExtensions.cpp
@@ -179,17 +179,17 @@ WebGLContext::IsExtensionSupported(WebGL
         // EXT_
         case WebGLExtensionID::EXT_blend_minmax:
             return WebGLExtensionBlendMinMax::IsSupported(this);
         case WebGLExtensionID::EXT_color_buffer_half_float:
             return WebGLExtensionColorBufferHalfFloat::IsSupported(this);
         case WebGLExtensionID::EXT_frag_depth:
             return WebGLExtensionFragDepth::IsSupported(this);
         case WebGLExtensionID::EXT_shader_texture_lod:
-            return gl->IsSupported(gl::GLFeature::shader_texture_lod);
+            return WebGLExtensionShaderTextureLod::IsSupported(this);
         case WebGLExtensionID::EXT_sRGB:
             return WebGLExtensionSRGB::IsSupported(this);
 
         // OES_
         case WebGLExtensionID::OES_element_index_uint:
             return gl->IsSupported(gl::GLFeature::element_index_uint);
         case WebGLExtensionID::OES_standard_derivatives:
             return gl->IsSupported(gl::GLFeature::standard_derivatives);

--- a/dom/canvas/WebGLExtensionShaderTextureLod.cpp
+++ b/dom/canvas/WebGLExtensionShaderTextureLod.cpp
@@ -9,17 +9,30 @@
 #include "mozilla/dom/WebGLRenderingContextBinding.h"
 #include "WebGLContext.h"
 
 namespace mozilla {
 
 WebGLExtensionShaderTextureLod::WebGLExtensionShaderTextureLod(WebGLContext* webgl)
     : WebGLExtensionBase(webgl)
 {
+    MOZ_ASSERT(IsSupported(webgl), "Don't construct extension if unsupported.");
 }
 
 WebGLExtensionShaderTextureLod::~WebGLExtensionShaderTextureLod()
 {
 }
 
+bool
+WebGLExtensionShaderTextureLod::IsSupported(const WebGLContext* webgl)
+{
+    gl::GLContext* gl = webgl->GL();
+    if (gl->IsGLES() && gl->Version() >= 300) {
+        // ANGLE's shader translator doesn't yet translate
+        // WebGL1+EXT_shader_texture_lod to ES3. (Bug 1491221)
+        return false;
+    }
+    return gl->IsSupported(gl::GLFeature::shader_texture_lod);
+}
+
 IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionShaderTextureLod, EXT_shader_texture_lod)
 
 } // namespace mozilla

--- a/dom/canvas/WebGLExtensions.h
+++ b/dom/canvas/WebGLExtensions.h
@@ -246,16 +246,18 @@ public:
 
 class WebGLExtensionShaderTextureLod
     : public WebGLExtensionBase
 {
 public:
     explicit WebGLExtensionShaderTextureLod(WebGLContext*);
     virtual ~WebGLExtensionShaderTextureLod();
 
+    static bool IsSupported(const WebGLContext* context);
+
     DECL_WEBGL_EXTENSION_GOOP
 };
 
 class WebGLExtensionTextureFilterAnisotropic
     : public WebGLExtensionBase
 {
 public:
     explicit WebGLExtensionTextureFilterAnisotropic(WebGLContext*);

--- a/dom/indexedDB/Key.cpp
+++ b/dom/indexedDB/Key.cpp
@@ -117,17 +117,16 @@ Key::ToLocaleBasedKey(Key& aTarget, cons
   }
 
   if (IsFloat() || IsDate() || IsBinary()) {
     aTarget.mBuffer = mBuffer;
     return NS_OK;
   }
 
   aTarget.mBuffer.Truncate();
-  aTarget.mBuffer.SetCapacity(mBuffer.Length());
 
   auto* it = reinterpret_cast<const unsigned char*>(mBuffer.BeginReading());
   auto* end = reinterpret_cast<const unsigned char*>(mBuffer.EndReading());
 
   // First we do a pass and see if there are any strings in this key. We only
   // want to copy/decode when necessary.
   bool canShareBuffers = true;
   while (it < end) {
@@ -145,16 +144,18 @@ Key::ToLocaleBasedKey(Key& aTarget, cons
   }
 
   if (canShareBuffers) {
     MOZ_ASSERT(it == end);
     aTarget.mBuffer = mBuffer;
     return NS_OK;
   }
 
+  aTarget.mBuffer.SetCapacity(mBuffer.Length());
+
   // A string was found, so we need to copy the data we've read so far
   auto* start = reinterpret_cast<const unsigned char*>(mBuffer.BeginReading());
   if (it > start) {
     char* buffer;
     if (!aTarget.mBuffer.GetMutableData(&buffer, it-start)) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
 

--- a/dom/media/AutoplayPolicy.cpp
+++ b/dom/media/AutoplayPolicy.cpp
@@ -22,31 +22,16 @@
 #include "nsIDocShellTreeItem.h"
 #include "nsPIDOMWindow.h"
 
 mozilla::LazyLogModule gAutoplayPermissionLog("Autoplay");
 
 #define AUTOPLAY_LOG(msg, ...)                                             \
   MOZ_LOG(gAutoplayPermissionLog, LogLevel::Debug, (msg, ##__VA_ARGS__))
 
-static const char*
-AllowAutoplayToStr(const uint32_t state)
-{
-  switch (state) {
-    case nsIAutoplay::ALLOWED:
-      return "allowed";
-    case nsIAutoplay::BLOCKED:
-      return "blocked";
-    case nsIAutoplay::PROMPT:
-      return "prompt";
-    default:
-      return "unknown";
-  }
-}
-
 namespace mozilla {
 namespace dom {
 
 static nsIDocument*
 ApproverDocOf(const nsIDocument& aDocument)
 {
   nsCOMPtr<nsIDocShell> ds = aDocument.GetDocShell();
   if (!ds) {
@@ -198,17 +183,17 @@ AutoplayPolicy::IsAllowedToPlay(const HT
   if (IsMediaElementAllowedToPlay(aElement)) {
     return true;
   }
 
   const bool result = IsMediaElementAllowedToPlay(aElement) ||
     autoplayDefault == nsIAutoplay::ALLOWED;
 
   AUTOPLAY_LOG("IsAllowedToPlay, mediaElement=%p, isAllowToPlay=%s",
-                &aElement, AllowAutoplayToStr(result));
+                &aElement, result ? "allowed" : "blocked");
 
   return result;
 }
 
 /* static */ bool
 AutoplayPolicy::IsAllowedToPlay(const AudioContext& aContext)
 {
   if (!Preferences::GetBool("media.autoplay.block-webaudio", false)) {

--- a/dom/media/MediaData.cpp
+++ b/dom/media/MediaData.cpp
@@ -250,17 +250,17 @@ ConstructPlanarYCbCrData(const VideoInfo
   data.mCbCrStride = Cb.mStride;
   data.mCbSkip = Cb.mSkip;
   data.mCrSkip = Cr.mSkip;
   data.mPicX = aPicture.x;
   data.mPicY = aPicture.y;
   data.mPicSize = aPicture.Size();
   data.mStereoMode = aInfo.mStereoMode;
   data.mYUVColorSpace = aBuffer.mYUVColorSpace;
-  data.mBitDepth = aBuffer.mBitDepth;
+  data.mColorDepth = aBuffer.mColorDepth;
   return data;
 }
 
 /* static */ bool
 VideoData::SetVideoDataToImage(PlanarYCbCrImage* aVideoImage,
                                const VideoInfo& aInfo,
                                const YCbCrBuffer &aBuffer,
                                const IntRect& aPicture,

--- a/dom/media/MediaData.h
+++ b/dom/media/MediaData.h
@@ -451,16 +451,17 @@ class PlanarYCbCrImage;
 class VideoInfo;
 
 // Holds a decoded video frame, in YCbCr format. These are queued in the reader.
 class VideoData : public MediaData
 {
 public:
   typedef gfx::IntRect IntRect;
   typedef gfx::IntSize IntSize;
+  typedef gfx::ColorDepth ColorDepth;
   typedef layers::ImageContainer ImageContainer;
   typedef layers::Image Image;
   typedef layers::PlanarYCbCrImage PlanarYCbCrImage;
 
   static const Type sType = VIDEO_DATA;
   static const char* sTypeName;
 
   // YCbCr data obtained from decoding the video. The index's are:
@@ -476,17 +477,17 @@ public:
       uint32_t mHeight;
       uint32_t mStride;
       uint32_t mOffset;
       uint32_t mSkip;
     };
 
     Plane mPlanes[3];
     YUVColorSpace mYUVColorSpace = YUVColorSpace::BT601;
-    uint32_t mBitDepth = 8;
+    ColorDepth mColorDepth = ColorDepth::COLOR_8;
   };
 
   class Listener
   {
   public:
     virtual void OnSentToCompositor() = 0;
     virtual ~Listener() { }
   };

--- a/dom/media/MediaInfo.h
+++ b/dom/media/MediaInfo.h
@@ -13,16 +13,17 @@
 #include "nsTArray.h"
 #include "AudioConfig.h"
 #include "ImageTypes.h"
 #include "MediaData.h"
 #include "TrackID.h" // for TrackID
 #include "TimeUnits.h"
 #include "mozilla/gfx/Point.h" // for gfx::IntSize
 #include "mozilla/gfx/Rect.h"  // for gfx::IntRect
+#include "mozilla/gfx/Types.h"  // for gfx::ColorDepth
 
 namespace mozilla {
 
 class AudioInfo;
 class VideoInfo;
 class TextInfo;
 
 class MetadataTag
@@ -222,17 +223,17 @@ public:
   VideoInfo(const VideoInfo& aOther)
     : TrackInfo(aOther)
     , mDisplay(aOther.mDisplay)
     , mStereoMode(aOther.mStereoMode)
     , mImage(aOther.mImage)
     , mCodecSpecificConfig(aOther.mCodecSpecificConfig)
     , mExtraData(aOther.mExtraData)
     , mRotation(aOther.mRotation)
-    , mBitDepth(aOther.mBitDepth)
+    , mColorDepth(aOther.mColorDepth)
     , mImageRect(aOther.mImageRect)
     , mAlphaPresent(aOther.mAlphaPresent)
   {
   }
 
   bool IsValid() const override
   {
     return mDisplay.width > 0 && mDisplay.height > 0;
@@ -331,17 +332,17 @@ public:
   RefPtr<MediaByteBuffer> mCodecSpecificConfig;
   RefPtr<MediaByteBuffer> mExtraData;
 
   // Describing how many degrees video frames should be rotated in clock-wise to
   // get correct view.
   Rotation mRotation;
 
   // Should be 8, 10 or 12. Default value is 8.
-  uint8_t mBitDepth = 8;
+  gfx::ColorDepth mColorDepth = gfx::ColorDepth::COLOR_8;
 
 private:
   // mImage may be cropped; currently only used with the WebM container.
   // A negative width or height indicate that no cropping is to occur.
   gfx::IntRect mImageRect;
 
   // Indicates whether or not frames may contain alpha information.
   bool mAlphaPresent = false;

--- a/dom/media/mp4/MP4Decoder.cpp
+++ b/dom/media/mp4/MP4Decoder.cpp
@@ -6,16 +6,17 @@
 
 #include "MP4Decoder.h"
 #include "H264.h"
 #include "MP4Demuxer.h"
 #include "MediaContainerType.h"
 #include "PDMFactory.h"
 #include "VideoUtils.h"
 #include "mozilla/StaticPrefs.h"
+#include "mozilla/gfx/Tools.h"
 #include "nsMimeTypes.h"
 
 namespace mozilla {
 
 static bool
 IsWhitelistedH264Codec(const nsAString& aCodec)
 {
   uint8_t profile = 0, constraint = 0, level = 0;
@@ -107,17 +108,18 @@ MP4Decoder::GetTracksInfo(const MediaCon
     if (IsVP9CodecString(codec)) {
       auto trackInfo =
         CreateTrackInfoWithMIMETypeAndContainerTypeExtraParameters(
           NS_LITERAL_CSTRING("video/vp9"), aType);
       uint8_t profile = 0;
       uint8_t level = 0;
       uint8_t bitDepth = 0;
       if (ExtractVPXCodecDetails(codec, profile, level, bitDepth)) {
-        trackInfo->GetAsVideoInfo()->mBitDepth = bitDepth;
+        trackInfo->GetAsVideoInfo()->mColorDepth =
+          gfx::ColorDepthForBitDepth(bitDepth);
       }
       tracks.AppendElement(std::move(trackInfo));
       continue;
     }
 #ifdef MOZ_AV1
     if (IsAV1CodecString(codec)) {
       tracks.AppendElement(
         CreateTrackInfoWithMIMETypeAndContainerTypeExtraParameters(

--- a/dom/media/platforms/PlatformDecoderModule.h
+++ b/dom/media/platforms/PlatformDecoderModule.h
@@ -189,34 +189,34 @@ public:
   virtual bool
   Supports(const TrackInfo& aTrackInfo,
            DecoderDoctorDiagnostics* aDiagnostics) const
   {
     if (!SupportsMimeType(aTrackInfo.mMimeType, aDiagnostics)) {
       return false;
     }
     const auto videoInfo = aTrackInfo.GetAsVideoInfo();
-    return !videoInfo || SupportsBitDepth(videoInfo->mBitDepth, aDiagnostics);
+    return !videoInfo || SupportsColorDepth(videoInfo->mColorDepth, aDiagnostics);
   }
 
 protected:
   PlatformDecoderModule() { }
   virtual ~PlatformDecoderModule() { }
 
   friend class H264Converter;
   friend class PDMFactory;
   friend class dom::RemoteDecoderModule;
   friend class EMEDecoderModule;
 
-  // Indicates if the PlatformDecoderModule supports decoding of aBitDepth.
-  // Should override this method when the platform can support bitDepth != 8.
-  virtual bool SupportsBitDepth(const uint8_t aBitDepth,
-                                DecoderDoctorDiagnostics* aDiagnostics) const
+  // Indicates if the PlatformDecoderModule supports decoding of aColorDepth.
+  // Should override this method when the platform can support color depth != 8.
+  virtual bool SupportsColorDepth(gfx::ColorDepth aColorDepth,
+                                  DecoderDoctorDiagnostics* aDiagnostics) const
   {
-    return aBitDepth == 8;
+    return aColorDepth == gfx::ColorDepth::COLOR_8;
   }
 
   // Creates a Video decoder. The layers backend is passed in so that
   // decoders can determine whether hardware accelerated decoding can be used.
   // Asynchronous decoding of video should be done in runnables dispatched
   // to aVideoTaskQueue. If the task queue isn't needed, the decoder should
   // not hold a reference to it.
   // On Windows the task queue's threads in have MSCOM initialized with

--- a/dom/media/platforms/ffmpeg/FFmpegDecoderModule.h
+++ b/dom/media/platforms/ffmpeg/FFmpegDecoderModule.h
@@ -73,28 +73,28 @@ public:
     if (audioCodec == AV_CODEC_ID_NONE && videoCodec == AV_CODEC_ID_NONE) {
       return false;
     }
     AVCodecID codec = audioCodec != AV_CODEC_ID_NONE ? audioCodec : videoCodec;
     return !!FFmpegDataDecoder<V>::FindAVCodec(mLib, codec);
   }
 
 protected:
-  bool SupportsBitDepth(const uint8_t aBitDepth,
-                        DecoderDoctorDiagnostics* aDiagnostics) const override
+  bool SupportsColorDepth(gfx::ColorDepth aColorDepth,
+                          DecoderDoctorDiagnostics* aDiagnostics) const override
   {
     // We don't support bitDepth > 8 when compositor backend is D3D11.
     // But we don't have KnowsCompositor or any object
     // that we can ask for the layersbackend type.
     // We should remove this restriction until
     // we solve the D3D11 compositor backend issue.
 #if defined(XP_LINUX) || defined(XP_MACOSX)
     return true;
 #endif
-    return aBitDepth == 8;
+    return aColorDepth == gfx::ColorDepth::COLOR_8;
   }
 
 private:
   FFmpegLibWrapper* mLib;
 };
 
 } // namespace mozilla
 

--- a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
+++ b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
@@ -293,31 +293,31 @@ FFmpegVideoDecoder<LIBAV_VER>::DoDecode(
 #if LIBAVCODEC_VERSION_MAJOR >= 57
       ||
       mCodecContext->pix_fmt == AV_PIX_FMT_YUV444P12LE
 #endif
       ) {
     b.mPlanes[1].mWidth = b.mPlanes[2].mWidth = mFrame->width;
     b.mPlanes[1].mHeight = b.mPlanes[2].mHeight = mFrame->height;
     if (mCodecContext->pix_fmt == AV_PIX_FMT_YUV444P10LE) {
-      b.mBitDepth = 10;
+      b.mColorDepth = gfx::ColorDepth::COLOR_10;
     }
 #if LIBAVCODEC_VERSION_MAJOR >= 57
     else if (mCodecContext->pix_fmt == AV_PIX_FMT_YUV444P12LE) {
-      b.mBitDepth = 12;
+      b.mColorDepth = gfx::ColorDepth::COLOR_12;
     }
 #endif
   } else if (mCodecContext->pix_fmt == AV_PIX_FMT_YUV422P) {
     b.mPlanes[1].mWidth = b.mPlanes[2].mWidth = (mFrame->width + 1) >> 1;
     b.mPlanes[1].mHeight = b.mPlanes[2].mHeight = mFrame->height;
   } else {
     b.mPlanes[1].mWidth = b.mPlanes[2].mWidth = (mFrame->width + 1) >> 1;
     b.mPlanes[1].mHeight = b.mPlanes[2].mHeight = (mFrame->height + 1) >> 1;
     if (mCodecContext->pix_fmt == AV_PIX_FMT_YUV420P10LE) {
-      b.mBitDepth = 10;
+      b.mColorDepth = gfx::ColorDepth::COLOR_10;
     }
   }
   if (mLib->av_frame_get_colorspace) {
     switch (mLib->av_frame_get_colorspace(mFrame)) {
       case AVCOL_SPC_BT709:
         b.mYUVColorSpace = YUVColorSpace::BT709;
         break;
       case AVCOL_SPC_SMPTE170M:

--- a/dom/media/platforms/wmf/WMFDecoderModule.cpp
+++ b/dom/media/platforms/wmf/WMFDecoderModule.cpp
@@ -194,17 +194,17 @@ WMFDecoderModule::SupportsMimeType(
   return Supports(*trackInfo, aDiagnostics);
 }
 
 bool
 WMFDecoderModule::Supports(const TrackInfo& aTrackInfo,
                            DecoderDoctorDiagnostics* aDiagnostics) const
 {
   const auto videoInfo = aTrackInfo.GetAsVideoInfo();
-  if (videoInfo && !SupportsBitDepth(videoInfo->mBitDepth, aDiagnostics)) {
+  if (videoInfo && !SupportsColorDepth(videoInfo->mColorDepth, aDiagnostics)) {
     return false;
   }
 
   if ((aTrackInfo.mMimeType.EqualsLiteral("audio/mp4a-latm") ||
        aTrackInfo.mMimeType.EqualsLiteral("audio/mp4")) &&
        WMFDecoderModule::HasAAC()) {
     const auto audioInfo = aTrackInfo.GetAsAudioInfo();
     if (audioInfo && audioInfo->mRate > 0) {

--- a/dom/media/webm/WebMDecoder.cpp
+++ b/dom/media/webm/WebMDecoder.cpp
@@ -53,17 +53,18 @@ WebMDecoder::GetTracksInfo(const MediaCo
         trackInfo = CreateTrackInfoWithMIMETypeAndContainerTypeExtraParameters(
           NS_LITERAL_CSTRING("video/vp8"), aType);
       }
       if (trackInfo) {
         uint8_t profile = 0;
         uint8_t level = 0;
         uint8_t bitDepth = 0;
         if (ExtractVPXCodecDetails(codec, profile, level, bitDepth)) {
-          trackInfo->GetAsVideoInfo()->mBitDepth = bitDepth;
+          trackInfo->GetAsVideoInfo()->mColorDepth =
+            gfx::ColorDepthForBitDepth(bitDepth);
         }
         tracks.AppendElement(std::move(trackInfo));
         continue;
       }
     }
 #ifdef MOZ_AV1
     if (StaticPrefs::MediaAv1Enabled() && IsAV1CodecString(codec)) {
       tracks.AppendElement(
@@ -97,17 +98,17 @@ WebMDecoder::IsSupportedType(const Media
   }
 
   if (tracks.IsEmpty()) {
     // WebM guarantees that the only codecs it contained are vp8, vp9, opus or vorbis.
     return true;
   }
 
   // Verify that we have a PDM that supports the whitelisted types, include
-  // bitdepth
+  // color depth
   RefPtr<PDMFactory> platform = new PDMFactory();
   for (const auto& track : tracks) {
     if (!track || !platform->Supports(*track, nullptr /* diagnostic */)) {
       return false;
     }
   }
 
   return true;

--- a/dom/presentation/PresentationSessionInfo.cpp
+++ b/dom/presentation/PresentationSessionInfo.cpp
@@ -1574,17 +1574,17 @@ PresentationPresentingInfo::ResolvedCall
   // Use Element to support both HTMLIFrameElement and nsXULElement.
   Element* frame = nullptr;
   nsresult rv = UNWRAP_OBJECT(Element, &obj, frame);
   if (NS_WARN_IF(!frame)) {
     ReplyError(NS_ERROR_DOM_OPERATION_ERR);
     return;
   }
 
-  nsCOMPtr<nsIFrameLoaderOwner> owner = do_QueryInterface((nsIFrameLoaderOwner*) frame);
+  nsCOMPtr<nsIFrameLoaderOwner> owner = do_QueryInterface(frame);
   if (NS_WARN_IF(!owner)) {
     ReplyError(NS_ERROR_DOM_OPERATION_ERR);
     return;
   }
 
   RefPtr<nsFrameLoader> frameLoader = owner->GetFrameLoader();
   if (NS_WARN_IF(!frameLoader)) {
     ReplyError(NS_ERROR_DOM_OPERATION_ERR);

--- a/dom/vr/test/mochitest/mochitest.ini
+++ b/dom/vr/test/mochitest/mochitest.ini
@@ -3,22 +3,30 @@
 support-files =
   VRSimulationDriver.js
   requestPresent.js
   runVRTest.js
   WebVRHelpers.js
 
 [test_vrController_displayId.html]
 # Enable Linux after Bug 1310655 # TIMED_OUT for Android.
-skip-if = (os != "win" && release_or_beta) || (os == "android")
+# skip-if = (os != "win" && release_or_beta) || (os == "android")
+# Re-enable this once Bug 1466702 has landed
+skip-if = true
 [test_vrDisplay_canvas2d.html]
-skip-if = (os != "win" && release_or_beta) # Enable Linux after Bug 1310655
+# skip-if = (os != "win" && release_or_beta) # Enable Linux after Bug 1310655
+# Re-enable this once Bug 1466702 has landed
+skip-if = true
 [test_vrDisplay_exitPresent.html]
-skip-if = (os != "win" && release_or_beta) # Enable Linux after Bug 1310655
+# skip-if = (os != "win" && release_or_beta) # Enable Linux after Bug 1310655
+# Re-enable this once Bug 1466702 has landed
+skip-if = true
 [test_vrDisplay_getFrameData.html]
 # Enable Linux after Bug 1310655, enable Android after Bug 1348246
-skip-if = (os != "win" && release_or_beta) || (os == "android")
+# skip-if = (os != "win" && release_or_beta) || (os == "android")
+# Re-enable this once Bug 1466702 has landed
+skip-if = true
 [test_vrDisplay_onvrdisplayconnect.html]
 skip-if = true
 [test_vrDisplay_onvrdisplaydeactivate_crosscontent.html]
 skip-if = true
 [test_vrDisplay_requestPresent.html]
 skip-if = true

--- a/dom/webidl/CaretStateChangedEvent.webidl
+++ b/dom/webidl/CaretStateChangedEvent.webidl
@@ -24,16 +24,17 @@ dictionary CaretStateChangedEventInit : 
   boolean selectionEditable = false;
   DOMString selectedTextContent = "";
 };
 
 [Constructor(DOMString type, optional CaretStateChangedEventInit eventInit),
  ChromeOnly]
 interface CaretStateChangedEvent : Event {
   readonly attribute boolean collapsed;
+  /* The bounding client rect is relative to the visual viewport. */
   readonly attribute DOMRectReadOnly? boundingClientRect;
   readonly attribute CaretChangedReason reason;
   readonly attribute boolean caretVisible;
   readonly attribute boolean caretVisuallyVisible;
   readonly attribute boolean selectionVisible;
   readonly attribute boolean selectionEditable;
   readonly attribute DOMString selectedTextContent;
 };

--- a/dom/webidl/Window.webidl
+++ b/dom/webidl/Window.webidl
@@ -48,17 +48,17 @@ typedef OfflineResourceList ApplicationC
   [Replaceable, Throws] readonly attribute BarProp statusbar;
   [Replaceable, Throws] readonly attribute BarProp toolbar;
   [Throws] attribute DOMString status;
   [Throws, CrossOriginCallable] void close();
   [Throws, CrossOriginReadable] readonly attribute boolean closed;
   [Throws] void stop();
   [Throws, CrossOriginCallable] void focus();
   [Throws, CrossOriginCallable] void blur();
-  [Replaceable] readonly attribute any event;
+  [Replaceable, Pref="dom.window.event.enabled"] readonly attribute any event;
 
   // other browsing contexts
   [Replaceable, Throws, CrossOriginReadable] readonly attribute WindowProxy frames;
   [Replaceable, CrossOriginReadable] readonly attribute unsigned long length;
   //[Unforgeable, Throws, CrossOriginReadable] readonly attribute WindowProxy top;
   [Unforgeable, Throws, CrossOriginReadable] readonly attribute WindowProxy? top;
   [Throws, CrossOriginReadable] attribute any opener;
   //[Throws] readonly attribute WindowProxy parent;

--- a/gfx/2d/Tools.h
+++ b/gfx/2d/Tools.h
@@ -105,51 +105,89 @@ BytesPerPixel(SurfaceFormat aFormat)
   case SurfaceFormat::Depth:
     return sizeof(uint16_t);
   default:
     return 4;
   }
 }
 
 static inline SurfaceFormat
-SurfaceFormatForAlphaBitDepth(uint32_t aBitDepth)
+SurfaceFormatForColorDepth(ColorDepth aColorDepth)
 {
-  if (aBitDepth == 8) {
-    return SurfaceFormat::A8;
-  } else if (aBitDepth == 10 ||
-             aBitDepth == 12) {
-    return SurfaceFormat::A16;
+  SurfaceFormat format = SurfaceFormat::A8;
+  switch (aColorDepth) {
+    case ColorDepth::COLOR_8:
+      break;
+    case ColorDepth::COLOR_10:
+    case ColorDepth::COLOR_12:
+      format = SurfaceFormat::A16;
+      break;
+    case ColorDepth::UNKNOWN:
+      MOZ_ASSERT_UNREACHABLE("invalid color depth value");
   }
-  MOZ_ASSERT_UNREACHABLE("Unsupported alpha bit depth");
-  return SurfaceFormat::UNKNOWN;
+  return format;
+}
+
+static inline uint32_t
+BitDepthForColorDepth(ColorDepth aColorDepth)
+{
+  uint32_t depth = 8;
+  switch (aColorDepth) {
+    case ColorDepth::COLOR_8:
+      break;
+    case ColorDepth::COLOR_10:
+      depth = 10;
+      break;
+    case ColorDepth::COLOR_12:
+      depth = 12;
+      break;
+    case ColorDepth::UNKNOWN:
+      MOZ_ASSERT_UNREACHABLE("invalid color depth value");
+  }
+  return depth;
 }
 
 static inline ColorDepth
-ColorDepthForAlphaBitDepth(uint32_t aBitDepth)
+ColorDepthForBitDepth(uint8_t aBitDepth)
 {
+  ColorDepth depth = ColorDepth::COLOR_8;
   switch (aBitDepth) {
-  case 8: return ColorDepth::COLOR_8;
-  case 10: return ColorDepth::COLOR_10;
-  case 12: return ColorDepth::COLOR_12;
-  default:
-    MOZ_ASSERT_UNREACHABLE("Unsupported alpha bit depth");
-    return ColorDepth::COLOR_8;
+    case 8:
+      break;
+    case 10:
+      depth = ColorDepth::COLOR_10;
+      break;
+    case 12:
+      depth = ColorDepth::COLOR_12;
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("invalid color depth value");
   }
+  return depth;
 }
 
 // 10 and 12 bits color depth image are using 16 bits integers for storage
-// As such we need to rescale the value from 8,10 or 12 to 16.
+// As such we need to rescale the value from 10 or 12 bits to 16.
 static inline uint32_t
-RescalingFactorForAlphaBitDepth(uint32_t aBitDepth)
+RescalingFactorForColorDepth(ColorDepth aColorDepth)
 {
-  MOZ_ASSERT(aBitDepth == 8 || aBitDepth == 10 || aBitDepth == 12);
-  uint32_t pixelBits =
-    8 * BytesPerPixel(SurfaceFormatForAlphaBitDepth(aBitDepth));
-  uint32_t paddingBits = pixelBits - aBitDepth;
-  return pow(2, paddingBits);
+  uint32_t factor = 1;
+  switch (aColorDepth) {
+    case ColorDepth::COLOR_8:
+      break;
+    case ColorDepth::COLOR_10:
+      factor = 64;
+      break;
+    case ColorDepth::COLOR_12:
+      factor = 16;
+      break;
+    case ColorDepth::UNKNOWN:
+      MOZ_ASSERT_UNREACHABLE("invalid color depth value");
+  }
+  return factor;
 }
 
 static inline bool
 IsOpaqueFormat(SurfaceFormat aFormat) {
   switch (aFormat) {
     case SurfaceFormat::B8G8R8X8:
     case SurfaceFormat::R8G8B8X8:
     case SurfaceFormat::X8R8G8B8:

--- a/gfx/2d/Types.h
+++ b/gfx/2d/Types.h
@@ -101,17 +101,17 @@ inline bool IsOpaque(SurfaceFormat aForm
     return false;
   }
 }
 
 enum class ColorDepth : uint8_t {
   COLOR_8,
   COLOR_10,
   COLOR_12,
-  MAX
+  UNKNOWN
 };
 
 enum class FilterType : int8_t {
   BLEND = 0,
   TRANSFORM,
   MORPHOLOGY,
   COLOR_MATRIX,
   FLOOD,

--- a/gfx/ipc/GPUProcessHost.cpp
+++ b/gfx/ipc/GPUProcessHost.cpp
@@ -155,24 +155,23 @@ GPUProcessHost::InitAfterConnect(bool aS
 void
 GPUProcessHost::Shutdown()
 {
   MOZ_ASSERT(!mShutdownRequested);
 
   mListener = nullptr;
 
   if (mGPUChild) {
-    mGPUChild->SendShutdownVR();
-
     // OnChannelClosed uses this to check if the shutdown was expected or
     // unexpected.
     mShutdownRequested = true;
 
     // The channel might already be closed if we got here unexpectedly.
     if (!mChannelClosed) {
+      mGPUChild->SendShutdownVR();
       mGPUChild->Close();
     }
 
 #ifndef NS_FREE_PERMANENT_DATA
     // No need to communicate shutdown, the GPU process doesn't need to
     // communicate anything back.
     KillHard("NormalShutdown");
 #endif

--- a/gfx/ipc/GfxMessageUtils.h
+++ b/gfx/ipc/GfxMessageUtils.h
@@ -700,16 +700,24 @@ template <>
 struct ParamTraits<mozilla::gfx::SurfaceFormat>
   : public ContiguousEnumSerializer<
              mozilla::gfx::SurfaceFormat,
              mozilla::gfx::SurfaceFormat::B8G8R8A8,
              mozilla::gfx::SurfaceFormat::UNKNOWN>
 {};
 
 template <>
+struct ParamTraits<mozilla::gfx::ColorDepth>
+  : public ContiguousEnumSerializer<
+             mozilla::gfx::ColorDepth,
+             mozilla::gfx::ColorDepth::COLOR_8,
+             mozilla::gfx::ColorDepth::UNKNOWN>
+{};
+
+template <>
 struct ParamTraits<mozilla::StereoMode>
   : public ContiguousEnumSerializer<
              mozilla::StereoMode,
              mozilla::StereoMode::MONO,
              mozilla::StereoMode::MAX>
 {};
 
 template <>

--- a/gfx/layers/BufferTexture.cpp
+++ b/gfx/layers/BufferTexture.cpp
@@ -1,22 +1,23 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 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/. */
 
 #include "BufferTexture.h"
-#include "mozilla/layers/ImageDataSerializer.h"
-#include "mozilla/layers/ISurfaceAllocator.h"
-#include "mozilla/layers/CompositableForwarder.h"
+#include "libyuv.h"
+#include "mozilla/Move.h"
+#include "mozilla/fallible.h"
+#include "mozilla/gfx/2D.h"
 #include "mozilla/gfx/Logging.h"
-#include "mozilla/gfx/2D.h"
-#include "mozilla/fallible.h"
-#include "libyuv.h"
+#include "mozilla/layers/CompositableForwarder.h"
+#include "mozilla/layers/ISurfaceAllocator.h"
+#include "mozilla/layers/ImageDataSerializer.h"
 
 #ifdef MOZ_WIDGET_GTK
 #include "gfxPlatformGtk.h"
 #endif
 
 namespace mozilla {
 namespace layers {
 
@@ -163,18 +164,18 @@ BufferTextureData::CreateInternal(Layers
 
 BufferTextureData*
 BufferTextureData::CreateForYCbCr(KnowsCompositor* aAllocator,
                                   gfx::IntSize aYSize,
                                   uint32_t aYStride,
                                   gfx::IntSize aCbCrSize,
                                   uint32_t aCbCrStride,
                                   StereoMode aStereoMode,
+                                  gfx::ColorDepth aColorDepth,
                                   YUVColorSpace aYUVColorSpace,
-                                  uint32_t aBitDepth,
                                   TextureFlags aTextureFlags)
 {
   uint32_t bufSize = ImageDataSerializer::ComputeYCbCrBufferSize(
     aYSize, aYStride, aCbCrSize, aCbCrStride);
   if (bufSize == 0) {
     return nullptr;
   }
 
@@ -195,18 +196,18 @@ BufferTextureData::CreateForYCbCr(KnowsC
                                      aAllocator->GetCompositorBackendType(),
                                      supportsTextureDirectMapping)
       : true;
 
   YCbCrDescriptor descriptor = YCbCrDescriptor(aYSize, aYStride,
                                                aCbCrSize, aCbCrStride,
                                                yOffset, cbOffset, crOffset,
                                                aStereoMode,
+                                               aColorDepth,
                                                aYUVColorSpace,
-                                               aBitDepth,
                                                hasIntermediateBuffer);
 
   return CreateInternal(aAllocator ? aAllocator->GetTextureForwarder()
                                    : nullptr,
                         descriptor,
                         gfx::BackendType::NONE,
                         bufSize,
                         aTextureFlags);
@@ -249,20 +250,20 @@ BufferTextureData::GetCbCrSize() const
 }
 
 Maybe<YUVColorSpace>
 BufferTextureData::GetYUVColorSpace() const
 {
   return ImageDataSerializer::YUVColorSpaceFromBufferDescriptor(mDescriptor);
 }
 
-Maybe<uint32_t>
-BufferTextureData::GetBitDepth() const
+Maybe<gfx::ColorDepth>
+BufferTextureData::GetColorDepth() const
 {
-  return ImageDataSerializer::BitDepthFromBufferDescriptor(mDescriptor);
+  return ImageDataSerializer::ColorDepthFromBufferDescriptor(mDescriptor);
 }
 
 Maybe<StereoMode>
 BufferTextureData::GetStereoMode() const
 {
   return ImageDataSerializer::StereoModeFromBufferDescriptor(mDescriptor);
 }
 
@@ -349,17 +350,18 @@ BufferTextureData::BorrowMappedYCbCrData
   const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
 
   uint8_t* data = GetBuffer();
   auto ySize = desc.ySize();
   auto cbCrSize = desc.cbCrSize();
 
   aMap.stereoMode = desc.stereoMode();
   aMap.metadata = nullptr;
-  uint32_t bytesPerPixel = desc.bitDepth() > 8 ? 2 : 1;
+  uint32_t bytesPerPixel =
+    BytesPerPixel(SurfaceFormatForColorDepth(desc.colorDepth()));
 
   aMap.y.data = data + desc.yOffset();
   aMap.y.size = ySize;
   aMap.y.stride = desc.yStride();
   aMap.y.skip = 0;
   aMap.y.bytesPerPixel = bytesPerPixel;
 
   aMap.cb.data = data + desc.cbOffset();
@@ -429,21 +431,21 @@ BufferTextureData::UpdateFromSurface(gfx
 
   srcSurf->Unmap();
   surface->Unmap();
 
   return true;
 }
 
 void
-BufferTextureData::SetDesciptor(const BufferDescriptor& aDescriptor)
+BufferTextureData::SetDescriptor(BufferDescriptor&& aDescriptor)
 {
   MOZ_ASSERT(mDescriptor.type() == BufferDescriptor::TYCbCrDescriptor);
   MOZ_ASSERT(mDescriptor.get_YCbCrDescriptor().ySize() == gfx::IntSize());
-  mDescriptor = aDescriptor;
+  mDescriptor = std::move(aDescriptor);
 }
 
 bool
 MemoryTextureData::Serialize(SurfaceDescriptor& aOutDescriptor)
 {
   MOZ_ASSERT(GetFormat() != gfx::SurfaceFormat::UNKNOWN);
   if (GetFormat() == gfx::SurfaceFormat::UNKNOWN) {
     return false;

--- a/gfx/layers/BufferTexture.h
+++ b/gfx/layers/BufferTexture.h
@@ -31,18 +31,18 @@ public:
                                    LayersIPCChannel* aAllocator);
 
   static BufferTextureData* CreateForYCbCr(KnowsCompositor* aAllocator,
                                            gfx::IntSize aYSize,
                                            uint32_t aYStride,
                                            gfx::IntSize aCbCrSize,
                                            uint32_t aCbCrStride,
                                            StereoMode aStereoMode,
+                                           gfx::ColorDepth aColorDepth,
                                            YUVColorSpace aYUVColorSpace,
-                                           uint32_t aBitDepth,
                                            TextureFlags aTextureFlags);
 
   virtual bool Lock(OpenMode aMode) override { return true; }
 
   virtual void Unlock() override {}
 
   virtual void FillInfo(TextureData::Info& aInfo) const override;
 
@@ -53,23 +53,23 @@ public:
   virtual bool BorrowMappedYCbCrData(MappedYCbCrTextureData& aMap) override;
 
   // use TextureClient's default implementation
   virtual bool UpdateFromSurface(gfx::SourceSurface* aSurface) override;
 
   virtual BufferTextureData* AsBufferTextureData() override { return this; }
 
   // Don't use this.
-  void SetDesciptor(const BufferDescriptor& aDesc);
+  void SetDescriptor(BufferDescriptor&& aDesc);
 
   Maybe<gfx::IntSize> GetCbCrSize() const;
 
   Maybe<YUVColorSpace> GetYUVColorSpace() const;
 
-  Maybe<uint32_t> GetBitDepth() const;
+  Maybe<gfx::ColorDepth> GetColorDepth() const;
 
   Maybe<StereoMode> GetStereoMode() const;
 
 protected:
   gfx::IntSize GetSize() const;
 
   gfx::SurfaceFormat GetFormat() const;
 

--- a/gfx/layers/D3D11YCbCrImage.cpp
+++ b/gfx/layers/D3D11YCbCrImage.cpp
@@ -30,17 +30,17 @@ bool
 D3D11YCbCrImage::SetData(KnowsCompositor* aAllocator,
                          ImageContainer* aContainer,
                          const PlanarYCbCrData& aData)
 {
   mPictureRect = IntRect(
     aData.mPicX, aData.mPicY, aData.mPicSize.width, aData.mPicSize.height);
   mYSize = aData.mYSize;
   mCbCrSize = aData.mCbCrSize;
-  mBitDepth = aData.mBitDepth;
+  mColorDepth = aData.mColorDepth;
   mColorSpace = aData.mYUVColorSpace;
 
   D3D11YCbCrRecycleAllocator* allocator =
     aContainer->GetD3D11YCbCrRecycleAllocator(aAllocator);
   if (!allocator) {
     return false;
   }
 
@@ -245,17 +245,17 @@ D3D11YCbCrImage::GetAsSourceSurface()
   }
 
   MOZ_ASSERT(mapCb.RowPitch == mapCr.RowPitch);
 
   data.mPicX = mPictureRect.X();
   data.mPicY = mPictureRect.Y();
   data.mPicSize = mPictureRect.Size();
   data.mStereoMode = StereoMode::MONO;
-  data.mBitDepth = mBitDepth;
+  data.mColorDepth = mColorDepth;
   data.mYUVColorSpace = mColorSpace;
   data.mYSkip = data.mCbSkip = data.mCrSkip = 0;
   data.mYSize = mYSize;
   data.mCbCrSize = mCbCrSize;
   data.mYChannel = static_cast<uint8_t*>(mapY.pData);
   data.mYStride = mapY.RowPitch;
   data.mCbChannel = static_cast<uint8_t*>(mapCb.pData);
   data.mCrChannel = static_cast<uint8_t*>(mapCr.pData);
@@ -350,17 +350,17 @@ DXGIYCbCrTextureAllocationHelper::IsComp
 {
   MOZ_ASSERT(aTextureClient->GetFormat() == gfx::SurfaceFormat::YUV);
 
   DXGIYCbCrTextureData* dxgiData = aTextureClient->GetInternalData()->AsDXGIYCbCrTextureData();
   if (!dxgiData ||
       aTextureClient->GetSize() != mData.mYSize ||
       dxgiData->GetYSize() != mData.mYSize ||
       dxgiData->GetCbCrSize() != mData.mCbCrSize ||
-      dxgiData->GetBitDepth() != mData.mBitDepth ||
+      dxgiData->GetColorDepth() != mData.mColorDepth ||
       dxgiData->GetYUVColorSpace() != mData.mYUVColorSpace) {
     return false;
   }
 
   ID3D11Texture2D* textureY = dxgiData->GetD3D11Texture(0);
   ID3D11Texture2D* textureCb = dxgiData->GetD3D11Texture(1);
   ID3D11Texture2D* textureCr = dxgiData->GetD3D11Texture(2);
 
@@ -384,22 +384,23 @@ DXGIYCbCrTextureAllocationHelper::IsComp
   }
 
   return true;
 }
 
 already_AddRefed<TextureClient>
 DXGIYCbCrTextureAllocationHelper::Allocate(KnowsCompositor* aAllocator)
 {
-  CD3D11_TEXTURE2D_DESC newDesc(
-    mData.mBitDepth == 8 ? DXGI_FORMAT_R8_UNORM : DXGI_FORMAT_R16_UNORM,
-    mData.mYSize.width,
-    mData.mYSize.height,
-    1,
-    1);
+  CD3D11_TEXTURE2D_DESC newDesc(mData.mColorDepth == gfx::ColorDepth::COLOR_8
+                                  ? DXGI_FORMAT_R8_UNORM
+                                  : DXGI_FORMAT_R16_UNORM,
+                                mData.mYSize.width,
+                                mData.mYSize.height,
+                                1,
+                                1);
   // WebRender requests keyed mutex
   if (mDevice == gfx::DeviceManagerDx::Get()->GetCompositorDevice() &&
       !gfxVars::UseWebRender()) {
     newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
   } else {
     newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
   }
 
@@ -439,17 +440,17 @@ DXGIYCbCrTextureAllocationHelper::Alloca
   return TextureClient::CreateWithData(
     DXGIYCbCrTextureData::Create(
       textureY,
       textureCb,
       textureCr,
       mData.mYSize,
       mData.mYSize,
       mData.mCbCrSize,
-      mData.mBitDepth,
+      mData.mColorDepth,
       mData.mYUVColorSpace),
     mTextureFlags,
     forwarder);
 }
 
 already_AddRefed<TextureClient>
 D3D11YCbCrRecycleAllocator::Allocate(SurfaceFormat aFormat,
                                      IntSize aSize,

--- a/gfx/layers/D3D11YCbCrImage.h
+++ b/gfx/layers/D3D11YCbCrImage.h
@@ -79,17 +79,17 @@ public:
   gfx::IntRect GetPictureRect() const override { return mPictureRect; }
 
 private:
   const DXGIYCbCrTextureData* GetData() const;
 
   gfx::IntSize mYSize;
   gfx::IntSize mCbCrSize;
   gfx::IntRect mPictureRect;
-  uint32_t mBitDepth;
+  gfx::ColorDepth mColorDepth;
   YUVColorSpace mColorSpace;
   RefPtr<TextureClient> mTextureClient;
 };
 
 } // namepace layers
 } // namespace mozilla
 
 #endif // GFX_D3D11_YCBCR_IMAGE_H

--- a/gfx/layers/Effects.h
+++ b/gfx/layers/Effects.h
@@ -157,26 +157,30 @@ struct EffectRGB : public TexturedEffect
     : TexturedEffect(EffectTypes::RGB, aTexture, aPremultiplied, aSamplingFilter)
   {}
 
   virtual const char* Name() override { return "EffectRGB"; }
 };
 
 struct EffectYCbCr : public TexturedEffect
 {
-  EffectYCbCr(TextureSource *aSource, YUVColorSpace aYUVColorSpace, uint32_t aBitDepth, gfx::SamplingFilter aSamplingFilter)
+  EffectYCbCr(TextureSource* aSource,
+              YUVColorSpace aYUVColorSpace,
+              gfx::ColorDepth aColorDepth,
+              gfx::SamplingFilter aSamplingFilter)
     : TexturedEffect(EffectTypes::YCBCR, aSource, false, aSamplingFilter)
     , mYUVColorSpace(aYUVColorSpace)
-    , mBitDepth(aBitDepth)
-  {}
+    , mColorDepth(aColorDepth)
+  {
+  }
 
   virtual const char* Name() override { return "EffectYCbCr"; }
 
   YUVColorSpace mYUVColorSpace;
-  uint32_t mBitDepth;
+  gfx::ColorDepth mColorDepth;
 };
 
 struct EffectNV12 : public TexturedEffect
 {
   EffectNV12(TextureSource *aSource, gfx::SamplingFilter aSamplingFilter)
     : TexturedEffect(EffectTypes::NV12, aSource, false, aSamplingFilter)
   {}
 
@@ -268,18 +272,20 @@ CreateTexturedEffect(TextureHost* aHost,
                      bool isAlphaPremultiplied)
 {
   MOZ_ASSERT(aHost);
   MOZ_ASSERT(aSource);
 
   RefPtr<TexturedEffect> result;
   if (aHost->GetReadFormat() == gfx::SurfaceFormat::YUV) {
     MOZ_ASSERT(aHost->GetYUVColorSpace() != YUVColorSpace::UNKNOWN);
-    result = new EffectYCbCr(
-      aSource, aHost->GetYUVColorSpace(), aHost->GetBitDepth(), aSamplingFilter);
+    result = new EffectYCbCr(aSource,
+                             aHost->GetYUVColorSpace(),
+                             aHost->GetColorDepth(),
+                             aSamplingFilter);
   } else {
     result = CreateTexturedEffect(aHost->GetReadFormat(),
                                   aSource,
                                   aSamplingFilter,
                                   isAlphaPremultiplied);
   }
   return result.forget();
 }

--- a/gfx/layers/ImageContainer.h
+++ b/gfx/layers/ImageContainer.h
@@ -11,16 +11,17 @@
 #include <sys/types.h>                  // for int32_t
 #include "gfxTypes.h"
 #include "ImageTypes.h"                 // for ImageFormat, etc
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT_HELPER2
 #include "mozilla/Mutex.h"              // for Mutex
 #include "mozilla/RecursiveMutex.h"     // for RecursiveMutex, etc
 #include "mozilla/TimeStamp.h"          // for TimeStamp
 #include "mozilla/gfx/Point.h"          // For IntSize
+#include "mozilla/gfx/Types.h"          // For ColorDepth
 #include "mozilla/layers/LayersTypes.h"  // for LayersBackend, etc
 #include "mozilla/layers/CompositorTypes.h"
 #include "mozilla/mozalloc.h"           // for operator delete, etc
 #include "nsAutoPtr.h"                  // for nsRefPtr, nsAutoArrayPtr, etc
 #include "nsAutoRef.h"                  // for nsCountedRef
 #include "nsCOMPtr.h"                   // for already_AddRefed
 #include "nsDebug.h"                    // for NS_ASSERTION
 #include "nsISupportsImpl.h"            // for Image::Release, etc
@@ -760,32 +761,32 @@ struct PlanarYCbCrData
   int32_t mCbSkip;
   int32_t mCrSkip;
   // Picture region
   uint32_t mPicX;
   uint32_t mPicY;
   gfx::IntSize mPicSize;
   StereoMode mStereoMode;
   YUVColorSpace mYUVColorSpace;
-  uint32_t mBitDepth;
+  gfx::ColorDepth mColorDepth;
 
   gfx::IntRect GetPictureRect() const
   {
     return gfx::IntRect(mPicX, mPicY,
                      mPicSize.width,
                      mPicSize.height);
   }
 
   PlanarYCbCrData()
     : mYChannel(nullptr), mYStride(0), mYSize(0, 0), mYSkip(0)
     , mCbChannel(nullptr), mCrChannel(nullptr)
     , mCbCrStride(0), mCbCrSize(0, 0) , mCbSkip(0), mCrSkip(0)
     , mPicX(0), mPicY(0), mPicSize(0, 0), mStereoMode(StereoMode::MONO)
     , mYUVColorSpace(YUVColorSpace::BT601)
-    , mBitDepth(8)
+    , mColorDepth(gfx::ColorDepth::COLOR_8)
   {}
 };
 
 /****** Image subtypes for the different formats ******/
 
 /**
  * We assume that the image data is in the REC 470M color space (see
  * Theora specification, section 4.3.1).

--- a/gfx/layers/ImageDataSerializer.cpp
+++ b/gfx/layers/ImageDataSerializer.cpp
@@ -172,25 +172,25 @@ Maybe<YUVColorSpace> YUVColorSpaceFromBu
       return Nothing();
     case BufferDescriptor::TYCbCrDescriptor:
       return Some(aDescriptor.get_YCbCrDescriptor().yUVColorSpace());
     default:
       MOZ_CRASH("GFX:  YUVColorSpaceFromBufferDescriptor");
   }
 }
 
-Maybe<uint32_t> BitDepthFromBufferDescriptor(const BufferDescriptor& aDescriptor)
+Maybe<gfx::ColorDepth> ColorDepthFromBufferDescriptor(const BufferDescriptor& aDescriptor)
 {
   switch (aDescriptor.type()) {
     case BufferDescriptor::TRGBDescriptor:
       return Nothing();
     case BufferDescriptor::TYCbCrDescriptor:
-      return Some(aDescriptor.get_YCbCrDescriptor().bitDepth());
+      return Some(aDescriptor.get_YCbCrDescriptor().colorDepth());
     default:
-      MOZ_CRASH("GFX:  BitDepthFromBufferDescriptor");
+      MOZ_CRASH("GFX:  ColorDepthFromBufferDescriptor");
   }
 }
 
 Maybe<StereoMode> StereoModeFromBufferDescriptor(const BufferDescriptor& aDescriptor)
 {
   switch (aDescriptor.type()) {
     case BufferDescriptor::TRGBDescriptor:
       return Nothing();
@@ -249,17 +249,17 @@ DataSourceSurfaceFromYCbCrDescriptor(uin
   ycbcrData.mYStride      = aDescriptor.yStride();
   ycbcrData.mYSize        = ySize;
   ycbcrData.mCbChannel    = GetCbChannel(aBuffer, aDescriptor);
   ycbcrData.mCrChannel    = GetCrChannel(aBuffer, aDescriptor);
   ycbcrData.mCbCrStride   = aDescriptor.cbCrStride();
   ycbcrData.mCbCrSize     = aDescriptor.cbCrSize();
   ycbcrData.mPicSize      = ySize;
   ycbcrData.mYUVColorSpace = aDescriptor.yUVColorSpace();
-  ycbcrData.mBitDepth     = aDescriptor.bitDepth();
+  ycbcrData.mColorDepth   = aDescriptor.colorDepth();
 
   gfx::ConvertYCbCrToRGB(ycbcrData,
                          gfx::SurfaceFormat::B8G8R8X8,
                          ySize,
                          map.mData,
                          map.mStride);
 
   result->Unmap();
@@ -281,16 +281,16 @@ ConvertAndScaleFromYCbCrDescriptor(uint8
   ycbcrData.mYStride      = aDescriptor.yStride();;
   ycbcrData.mYSize        = aDescriptor.ySize();
   ycbcrData.mCbChannel    = GetCbChannel(aBuffer, aDescriptor);
   ycbcrData.mCrChannel    = GetCrChannel(aBuffer, aDescriptor);
   ycbcrData.mCbCrStride   = aDescriptor.cbCrStride();
   ycbcrData.mCbCrSize     = aDescriptor.cbCrSize();
   ycbcrData.mPicSize      = aDescriptor.ySize();
   ycbcrData.mYUVColorSpace = aDescriptor.yUVColorSpace();
-  ycbcrData.mBitDepth     = aDescriptor.bitDepth();
+  ycbcrData.mColorDepth   = aDescriptor.colorDepth();
 
   gfx::ConvertYCbCrToRGB(ycbcrData, aDestFormat, aDestSize, aDestBuffer, aStride);
 }
 
 } // namespace ImageDataSerializer
 } // namespace layers
 } // namespace mozilla

--- a/gfx/layers/ImageDataSerializer.h
+++ b/gfx/layers/ImageDataSerializer.h
@@ -60,17 +60,17 @@ void ComputeYCbCrOffsets(int32_t yStride
 gfx::SurfaceFormat FormatFromBufferDescriptor(const BufferDescriptor& aDescriptor);
 
 gfx::IntSize SizeFromBufferDescriptor(const BufferDescriptor& aDescriptor);
 
 Maybe<gfx::IntSize> CbCrSizeFromBufferDescriptor(const BufferDescriptor& aDescriptor);
 
 Maybe<YUVColorSpace> YUVColorSpaceFromBufferDescriptor(const BufferDescriptor& aDescriptor);
 
-Maybe<uint32_t> BitDepthFromBufferDescriptor(const BufferDescriptor& aDescriptor);
+Maybe<gfx::ColorDepth> ColorDepthFromBufferDescriptor(const BufferDescriptor& aDescriptor);
 
 Maybe<StereoMode> StereoModeFromBufferDescriptor(const BufferDescriptor& aDescriptor);
 
 uint8_t* GetYChannel(uint8_t* aBuffer, const YCbCrDescriptor& aDescriptor);
 
 uint8_t* GetCbChannel(uint8_t* aBuffer, const YCbCrDescriptor& aDescriptor);
 
 uint8_t* GetCrChannel(uint8_t* aBuffer, const YCbCrDescriptor& aDescriptor);

--- a/gfx/layers/TextureSourceProvider.cpp
+++ b/gfx/layers/TextureSourceProvider.cpp
@@ -41,32 +41,25 @@ TextureSourceProvider::ReadUnlockTexture
   for (auto it = texturesIdsToUnlockByPid.ConstIter(); !it.Done(); it.Next()) {
     TextureSync::SetTexturesUnlocked(it.Key(), *it.UserData());
   }
 #else
   for (auto& texture : mUnlockAfterComposition) {
     texture->ReadUnlock();
   }
 #endif
-  mReferenceUntilAfterComposition.Clear();
   mUnlockAfterComposition.Clear();
 }
 
 void
 TextureSourceProvider::UnlockAfterComposition(TextureHost* aTexture)
 {
   mUnlockAfterComposition.AppendElement(aTexture);
 }
 
-void
-TextureSourceProvider::ReferenceUntilAfterComposition(DataTextureSource* aTextureSource)
-{
-  mReferenceUntilAfterComposition.AppendElement(aTextureSource);
-}
-
 bool
 TextureSourceProvider::NotifyNotUsedAfterComposition(TextureHost* aTextureHost)
 {
   mNotifyNotUsedAfterComposition.AppendElement(aTextureHost);
 
   // If Compositor holds many TextureHosts without compositing,
   // the TextureHosts should be flushed to reduce memory consumption.
   const int thresholdCount = 5;

--- a/gfx/layers/TextureSourceProvider.h
+++ b/gfx/layers/TextureSourceProvider.h
@@ -59,23 +59,16 @@ public:
   /// Most compositor backends operate asynchronously under the hood. This
   /// means that when a layer stops using a texture it is often desirable to
   /// wait for the end of the next composition before releasing the texture's
   /// ReadLock.
   /// This function provides a convenient way to do this delayed unlocking, if
   /// the texture itself requires it.
   virtual void UnlockAfterComposition(TextureHost* aTexture);
 
-  /// This is used for client storage support on OSX. On Nvidia hardware, it
-  /// seems that if we glDeleteTextures on a texture too early, even if we've
-  /// waited on the texture with glFinishObjectAPPLE, we'll see visual defects.
-  /// This just holds a reference to the texture until ReadUnlockTextures,
-  /// but we don't need to unlock it since we have already done so.
-  void ReferenceUntilAfterComposition(DataTextureSource* aTextureSource);
-
   /// Most compositor backends operate asynchronously under the hood. This
   /// means that when a layer stops using a texture it is often desirable to
   /// wait for the end of the next composition before NotifyNotUsed() call.
   /// This function provides a convenient way to do this delayed NotifyNotUsed()
   /// call, if the texture itself requires it.
   /// See bug 1260611 and bug 1252835
   ///
   /// Returns true if notified, false otherwise.
@@ -133,19 +126,16 @@ protected:
   void ReadUnlockTextures();
 
   virtual ~TextureSourceProvider();
 
 private:
   // An array of locks that will need to be unlocked after the next composition.
   nsTArray<RefPtr<TextureHost>> mUnlockAfterComposition;
 
-  // See ReferenceUntilAfterComposition.
-  nsTArray<RefPtr<DataTextureSource>> mReferenceUntilAfterComposition;
-
   // An array of TextureHosts that will need to call NotifyNotUsed() after the next composition.
   nsTArray<RefPtr<TextureHost>> mNotifyNotUsedAfterComposition;
 };
 
 } // namespace layers
 } // namespace mozilla
 
 #endif // mozilla_gfx_layers_TextureSourceProvider_h

--- a/gfx/layers/client/ImageClient.cpp
+++ b/gfx/layers/client/ImageClient.cpp
@@ -100,18 +100,18 @@ ImageClient::CreateTextureClientForImage
     const PlanarYCbCrData* data = ycbcr->GetData();
     if (!data) {
       return nullptr;
     }
     texture = TextureClient::CreateForYCbCr(aForwarder,
                                             data->mYSize, data->mYStride,
                                             data->mCbCrSize, data->mCbCrStride,
                                             data->mStereoMode,
+                                            data->mColorDepth,
                                             data->mYUVColorSpace,
-                                            data->mBitDepth,
                                             TextureFlags::DEFAULT);
     if (!texture) {
       return nullptr;
     }
 
     TextureClientAutoLock autoLock(texture, OpenMode::OPEN_WRITE_ONLY);
     if (!autoLock.Succeeded()) {
       return nullptr;

--- a/gfx/layers/client/TextureClient.cpp
+++ b/gfx/layers/client/TextureClient.cpp
@@ -1300,34 +1300,37 @@ TextureClient::CreateForRawBufferAccess(
 // static
 already_AddRefed<TextureClient>
 TextureClient::CreateForYCbCr(KnowsCompositor* aAllocator,
                               gfx::IntSize aYSize,
                               uint32_t aYStride,
                               gfx::IntSize aCbCrSize,
                               uint32_t aCbCrStride,
                               StereoMode aStereoMode,
+                              gfx::ColorDepth aColorDepth,
                               YUVColorSpace aYUVColorSpace,
-                              uint32_t aBitDepth,
                               TextureFlags aTextureFlags)
 {
   if (!aAllocator || !aAllocator->GetLayersIPCActor()->IPCOpen()) {
     return nullptr;
   }
 
   if (!gfx::Factory::AllowedSurfaceSize(aYSize)) {
     return nullptr;
   }
 
-  TextureData* data =
-    BufferTextureData::CreateForYCbCr(aAllocator,
-                                      aYSize, aYStride,
-                                      aCbCrSize, aCbCrStride,
-                                      aStereoMode, aYUVColorSpace,
-                                      aBitDepth, aTextureFlags);
+  TextureData* data = BufferTextureData::CreateForYCbCr(aAllocator,
+                                                        aYSize,
+                                                        aYStride,
+                                                        aCbCrSize,
+                                                        aCbCrStride,
+                                                        aStereoMode,
+                                                        aColorDepth,
+                                                        aYUVColorSpace,
+                                                        aTextureFlags);
   if (!data) {
     return nullptr;
   }
 
   return MakeAndAddRef<TextureClient>(data, aTextureFlags,
                                       aAllocator->GetTextureForwarder());
 }
 
@@ -1791,33 +1794,34 @@ UpdateYCbCrTextureClient(TextureClient* 
   MOZ_ASSERT(aData.mCbSkip == aData.mCrSkip);
 
   MappedYCbCrTextureData mapped;
   if (!aTexture->BorrowMappedYCbCrData(mapped)) {
     NS_WARNING("Failed to extract YCbCr info!");
     return false;
   }
 
+  uint32_t bytesPerPixel =
+    BytesPerPixel(SurfaceFormatForColorDepth(aData.mColorDepth));
   MappedYCbCrTextureData srcData;
   srcData.y.data = aData.mYChannel;
   srcData.y.size = aData.mYSize;
   srcData.y.stride = aData.mYStride;
   srcData.y.skip = aData.mYSkip;
-  MOZ_ASSERT(aData.mBitDepth == 8 || (aData.mBitDepth > 8 && aData.mBitDepth <= 16));
-  srcData.y.bytesPerPixel = (aData.mBitDepth > 8) ? 2 : 1;
+  srcData.y.bytesPerPixel = bytesPerPixel;
   srcData.cb.data = aData.mCbChannel;
   srcData.cb.size = aData.mCbCrSize;
   srcData.cb.stride = aData.mCbCrStride;
   srcData.cb.skip = aData.mCbSkip;
-  srcData.cb.bytesPerPixel = (aData.mBitDepth > 8) ? 2 : 1;
+  srcData.cb.bytesPerPixel = bytesPerPixel;
   srcData.cr.data = aData.mCrChannel;
   srcData.cr.size = aData.mCbCrSize;
   srcData.cr.stride = aData.mCbCrStride;
   srcData.cr.skip = aData.mCrSkip;
-  srcData.cr.bytesPerPixel = (aData.mBitDepth > 8) ? 2 : 1;
+  srcData.cr.bytesPerPixel = bytesPerPixel;
   srcData.metadata = nullptr;
 
   if (!srcData.CopyInto(mapped)) {
     NS_WARNING("Failed to copy image data!");
     return false;
   }
 
   if (TextureRequiresLocking(aTexture->GetFlags())) {

--- a/gfx/layers/client/TextureClient.h
+++ b/gfx/layers/client/TextureClient.h
@@ -360,18 +360,18 @@ public:
   // Creates and allocates a TextureClient supporting the YCbCr format.
   static already_AddRefed<TextureClient>
   CreateForYCbCr(KnowsCompositor* aAllocator,
                  gfx::IntSize aYSize,
                  uint32_t aYStride,
                  gfx::IntSize aCbCrSize,
                  uint32_t aCbCrStride,
                  StereoMode aStereoMode,
+                 gfx::ColorDepth aColorDepth,
                  YUVColorSpace aYUVColorSpace,
-                 uint32_t aBitDepth,
                  TextureFlags aTextureFlags);
 
   // Creates and allocates a TextureClient (can be accessed through raw
   // pointers).
   static already_AddRefed<TextureClient>
   CreateForRawBufferAccess(KnowsCompositor* aAllocator,
                            gfx::SurfaceFormat aFormat,
                            gfx::IntSize aSize,

--- a/gfx/layers/client/TextureClientRecycleAllocator.cpp
+++ b/gfx/layers/client/TextureClientRecycleAllocator.cpp
@@ -104,34 +104,34 @@ YCbCrTextureClientAllocationHelper::IsCo
 
   BufferTextureData* bufferData = aTextureClient->GetInternalData()->AsBufferTextureData();
   if (!bufferData ||
       aTextureClient->GetSize() != mData.mYSize ||
       bufferData->GetCbCrSize().isNothing() ||
       bufferData->GetCbCrSize().ref() != mData.mCbCrSize ||
       bufferData->GetYUVColorSpace().isNothing() ||
       bufferData->GetYUVColorSpace().ref() != mData.mYUVColorSpace ||
-      bufferData->GetBitDepth().isNothing() ||
-      bufferData->GetBitDepth().ref() != mData.mBitDepth ||
+      bufferData->GetColorDepth().isNothing() ||
+      bufferData->GetColorDepth().ref() != mData.mColorDepth ||
       bufferData->GetStereoMode().isNothing() ||
       bufferData->GetStereoMode().ref() != mData.mStereoMode) {
     return false;
   }
   return true;
 }
 
 already_AddRefed<TextureClient>
 YCbCrTextureClientAllocationHelper::Allocate(KnowsCompositor* aAllocator)
 {
   return TextureClient::CreateForYCbCr(aAllocator,
                                        mData.mYSize, mData.mYStride,
                                        mData.mCbCrSize, mData.mCbCrStride,
                                        mData.mStereoMode,
+                                       mData.mColorDepth,
                                        mData.mYUVColorSpace,
-                                       mData.mBitDepth,
                                        mTextureFlags);
 }
 
 TextureClientRecycleAllocator::TextureClientRecycleAllocator(KnowsCompositor* aAllocator)
   : mSurfaceAllocator(aAllocator)
   , mMaxPooledSize(kMaxPooledSized)
   , mLock("TextureClientRecycleAllocatorImp.mLock")
   , mIsDestroyed(false)

--- a/gfx/layers/composite/TextureHost.cpp
+++ b/gfx/layers/composite/TextureHost.cpp
@@ -922,20 +922,16 @@ BufferTextureHost::MaybeNotifyUnlocked()
 
 void
 BufferTextureHost::UnbindTextureSource()
 {
   if (mFirstSource && mFirstSource->IsOwnedBy(this)) {
     mFirstSource->Unbind();
   }
 
-  if (mFirstSource && mFirstSource->IsDirectMap() && mProvider) {
-    mProvider->ReferenceUntilAfterComposition(mFirstSource);
-  }
-
   // This texture is not used by any layer anymore.
   // If the texture doesn't have an intermediate buffer, it means we are
   // compositing synchronously on the CPU, so we don't need to wait until
   // the end of the next composition to ReadUnlock (which other textures do
   // by default).
   // If the texture has an intermediate buffer we don't care either because
   // texture uploads are also performed synchronously for BufferTextureHost.
   ReadUnlock();
@@ -963,24 +959,24 @@ BufferTextureHost::GetYUVColorSpace() co
 {
   if (mFormat == gfx::SurfaceFormat::YUV) {
     const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
     return desc.yUVColorSpace();
   }
   return YUVColorSpace::UNKNOWN;
 }
 
-uint32_t
-BufferTextureHost::GetBitDepth() const
+gfx::ColorDepth
+BufferTextureHost::GetColorDepth() const
 {
   if (mFormat == gfx::SurfaceFormat::YUV) {
     const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
-    return desc.bitDepth();
+    return desc.colorDepth();
   }
-  return 8;
+  return gfx::ColorDepth::COLOR_8;
 }
 
 bool
 BufferTextureHost::UploadIfNeeded()
 {
   return MaybeUpload(!mNeedsFullUpdate ? &mMaybeUpdatedRegion : nullptr);
 }
 
@@ -1083,27 +1079,27 @@ BufferTextureHost::Upload(nsIntRegion *a
       srcU = mFirstSource->GetNextSibling()->AsDataTextureSource();
       srcV = mFirstSource->GetNextSibling()->GetNextSibling()->AsDataTextureSource();
     }
 
     RefPtr<gfx::DataSourceSurface> tempY =
       gfx::Factory::CreateWrappingDataSourceSurface(ImageDataSerializer::GetYChannel(buf, desc),
                                                     desc.yStride(),
                                                     desc.ySize(),
-                                                    SurfaceFormatForAlphaBitDepth(desc.bitDepth()));
+                                                    SurfaceFormatForColorDepth(desc.colorDepth()));
     RefPtr<gfx::DataSourceSurface> tempCb =
       gfx::Factory::CreateWrappingDataSourceSurface(ImageDataSerializer::GetCbChannel(buf, desc),
                                                     desc.cbCrStride(),
                                                     desc.cbCrSize(),
-                                                    SurfaceFormatForAlphaBitDepth(desc.bitDepth()));
+                                                    SurfaceFormatForColorDepth(desc.colorDepth()));
     RefPtr<gfx::DataSourceSurface> tempCr =
       gfx::Factory::CreateWrappingDataSourceSurface(ImageDataSerializer::GetCrChannel(buf, desc),
                                                     desc.cbCrStride(),
                                                     desc.cbCrSize(),
-                                                    SurfaceFormatForAlphaBitDepth(desc.bitDepth()));
+                                                    SurfaceFormatForColorDepth(desc.colorDepth()));
     // We don't support partial updates for Y U V textures
     NS_ASSERTION(!aRegion, "Unsupported partial updates for YCbCr textures");
     if (!tempY ||
         !tempCb ||
         !tempCr ||
         !srcY->Update(tempY) ||
         !srcU->Update(tempCb) ||
         !srcV->Update(tempCr)) {

--- a/gfx/layers/composite/TextureHost.h
+++ b/gfx/layers/composite/TextureHost.h
@@ -446,19 +446,19 @@ public:
    * Return the format used for reading the texture.
    * Apple's YCBCR_422 is R8G8B8X8.
    */
   virtual gfx::SurfaceFormat GetReadFormat() const { return GetFormat(); }
 
   virtual YUVColorSpace GetYUVColorSpace() const { return YUVColorSpace::UNKNOWN; }
 
   /**
-   * Return the bit depth of the image. Used with YUV textures.
+   * Return the color depth of the image. Used with YUV textures.
    */
-  virtual uint32_t GetBitDepth() const { return 8; }
+  virtual gfx::ColorDepth GetColorDepth() const { return gfx::ColorDepth::COLOR_8; }
 
   /**
    * Called during the transaction. The TextureSource may or may not be composited.
    *
    * Note that this is called outside of lock/unlock.
    */
   virtual void PrepareTextureSource(CompositableTextureSourceRef& aTexture) {}
 
@@ -752,17 +752,17 @@ public:
    *
    * If the shared format is YCbCr and the compositor does not support it,
    * GetFormat will be RGB32 (even though mFormat is SurfaceFormat::YUV).
    */
   virtual gfx::SurfaceFormat GetFormat() const override;
 
   virtual YUVColorSpace GetYUVColorSpace() const override;
 
-  virtual uint32_t GetBitDepth() const override;
+  virtual gfx::ColorDepth GetColorDepth() const override;
 
   virtual gfx::IntSize GetSize() const override { return mSize; }
 
   virtual already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
 
   virtual bool HasIntermediateBuffer() const override { return mHasIntermediateBuffer; }
 
   virtual BufferTextureHost* AsBufferTextureHost() override { return this; }

--- a/gfx/layers/d3d11/CompositorD3D11.cpp
+++ b/gfx/layers/d3d11/CompositorD3D11.cpp
@@ -893,17 +893,17 @@ CompositorD3D11::DrawGeometry(const Geom
         return;
       }
 
       const float* yuvToRgb = gfxUtils::YuvToRgbMatrix4x3RowMajor(ycbcrEffect->mYUVColorSpace);
       memcpy(&mPSConstants.yuvColorMatrix, yuvToRgb, sizeof(mPSConstants.yuvColorMatrix));
 
       // Adjust range according to the bit depth.
       mPSConstants.vCoefficient[0] =
-        RescalingFactorForAlphaBitDepth(ycbcrEffect->mBitDepth);
+        RescalingFactorForColorDepth(ycbcrEffect->mColorDepth);
 
       TextureSourceD3D11* sourceY = source->GetSubSource(Y)->AsSourceD3D11();
       TextureSourceD3D11* sourceCb = source->GetSubSource(Cb)->AsSourceD3D11();
       TextureSourceD3D11* sourceCr = source->GetSubSource(Cr)->AsSourceD3D11();
 
       ID3D11ShaderResourceView* srViews[3] = { sourceY->GetShaderResourceView(),
                                                sourceCb->GetShaderResourceView(),
                                                sourceCr->GetShaderResourceView() };

--- a/gfx/layers/d3d11/TextureD3D11.cpp
+++ b/gfx/layers/d3d11/TextureD3D11.cpp
@@ -621,17 +621,17 @@ DXGIYCbCrTextureData::Create(IDirect3DTe
                              IDirect3DTexture9* aTextureCb,
                              IDirect3DTexture9* aTextureCr,
                              HANDLE aHandleY,
                              HANDLE aHandleCb,
                              HANDLE aHandleCr,
                              const gfx::IntSize& aSize,
                              const gfx::IntSize& aSizeY,
                              const gfx::IntSize& aSizeCbCr,
-                             uint32_t aBitDepth,
+                             gfx::ColorDepth aColorDepth,
                              YUVColorSpace aYUVColorSpace)
 {
   if (!aHandleY || !aHandleCb || !aHandleCr ||
       !aTextureY || !aTextureCb || !aTextureCr) {
     return nullptr;
   }
 
   DXGIYCbCrTextureData* texture = new DXGIYCbCrTextureData();
@@ -639,30 +639,30 @@ DXGIYCbCrTextureData::Create(IDirect3DTe
   texture->mHandles[1] = aHandleCb;
   texture->mHandles[2] = aHandleCr;
   texture->mD3D9Textures[0] = aTextureY;
   texture->mD3D9Textures[1] = aTextureCb;
   texture->mD3D9Textures[2] = aTextureCr;
   texture->mSize = aSize;
   texture->mSizeY = aSizeY;
   texture->mSizeCbCr = aSizeCbCr;
-  texture->mBitDepth = aBitDepth;
+  texture->mColorDepth = aColorDepth;
   texture->mYUVColorSpace = aYUVColorSpace;
 
   return texture;
 }
 
 DXGIYCbCrTextureData*
 DXGIYCbCrTextureData::Create(ID3D11Texture2D* aTextureY,
                              ID3D11Texture2D* aTextureCb,
                              ID3D11Texture2D* aTextureCr,
                              const gfx::IntSize& aSize,
                              const gfx::IntSize& aSizeY,
                              const gfx::IntSize& aSizeCbCr,
-                             uint32_t aBitDepth,
+                             gfx::ColorDepth aColorDepth,
                              YUVColorSpace aYUVColorSpace)
 {
   if (!aTextureY || !aTextureCb || !aTextureCr) {
     return nullptr;
   }
 
   aTextureY->SetPrivateDataInterface(sD3D11TextureUsage,
     new TextureMemoryMeasurer(aSize.width * aSize.height));
@@ -701,17 +701,17 @@ DXGIYCbCrTextureData::Create(ID3D11Textu
   texture->mHandles[1] = handleCb;
   texture->mHandles[2] = handleCr;
   texture->mD3D11Textures[0] = aTextureY;
   texture->mD3D11Textures[1] = aTextureCb;
   texture->mD3D11Textures[2] = aTextureCr;
   texture->mSize = aSize;
   texture->mSizeY = aSizeY;
   texture->mSizeCbCr = aSizeCbCr;
-  texture->mBitDepth = aBitDepth;
+  texture->mColorDepth = aColorDepth;
   texture->mYUVColorSpace = aYUVColorSpace;
 
   return texture;
 }
 
 void
 DXGIYCbCrTextureData::FillInfo(TextureData::Info& aInfo) const
 {
@@ -720,20 +720,24 @@ DXGIYCbCrTextureData::FillInfo(TextureDa
   aInfo.supportsMoz2D = false;
   aInfo.hasIntermediateBuffer = false;
   aInfo.hasSynchronization = false;
 }
 
 void
 DXGIYCbCrTextureData::SerializeSpecific(SurfaceDescriptorDXGIYCbCr* const aOutDesc)
 {
-  *aOutDesc = SurfaceDescriptorDXGIYCbCr(
-    (WindowsHandle)mHandles[0], (WindowsHandle)mHandles[1], (WindowsHandle)mHandles[2],
-    mSize, mSizeY, mSizeCbCr, mBitDepth, mYUVColorSpace
-  );
+  *aOutDesc = SurfaceDescriptorDXGIYCbCr((WindowsHandle)mHandles[0],
+                                         (WindowsHandle)mHandles[1],
+                                         (WindowsHandle)mHandles[2],
+                                         mSize,
+                                         mSizeY,
+                                         mSizeCbCr,
+                                         mColorDepth,
+                                         mYUVColorSpace);
 }
 
 bool
 DXGIYCbCrTextureData::Serialize(SurfaceDescriptor& aOutDescriptor)
 {
   SurfaceDescriptorDXGIYCbCr desc;
   SerializeSpecific(&desc);
 
@@ -1171,17 +1175,17 @@ DXGITextureHostD3D11::PushDisplayItems(w
 }
 
 DXGIYCbCrTextureHostD3D11::DXGIYCbCrTextureHostD3D11(TextureFlags aFlags,
   const SurfaceDescriptorDXGIYCbCr& aDescriptor)
   : TextureHost(aFlags)
   , mSize(aDescriptor.size())
   , mSizeCbCr(aDescriptor.sizeCbCr())
   , mIsLocked(false)
-  , mBitDepth(aDescriptor.bitDepth())
+  , mColorDepth(aDescriptor.colorDepth())
   , mYUVColorSpace(aDescriptor.yUVColorSpace())
 {
   mHandles[0] = aDescriptor.handleY();
   mHandles[1] = aDescriptor.handleCb();
   mHandles[2] = aDescriptor.handleCr();
 }
 
 bool

--- a/gfx/layers/d3d11/TextureD3D11.h
+++ b/gfx/layers/d3d11/TextureD3D11.h
@@ -140,27 +140,27 @@ public:
          IDirect3DTexture9* aTextureCb,
          IDirect3DTexture9* aTextureCr,
          HANDLE aHandleY,
          HANDLE aHandleCb,
          HANDLE aHandleCr,
          const gfx::IntSize& aSize,
          const gfx::IntSize& aSizeY,
          const gfx::IntSize& aSizeCbCr,
-         uint32_t aBitDepth,
+         gfx::ColorDepth aColorDepth,
          YUVColorSpace aYUVColorSpace);
 
   static DXGIYCbCrTextureData*
   Create(ID3D11Texture2D* aTextureCb,
          ID3D11Texture2D* aTextureY,
          ID3D11Texture2D* aTextureCr,
          const gfx::IntSize& aSize,
          const gfx::IntSize& aSizeY,
          const gfx::IntSize& aSizeCbCr,
-         uint32_t aBitDepth,
+         gfx::ColorDepth aColorDepth,
          YUVColorSpace aYUVColorSpace);
 
   virtual bool Lock(OpenMode) override { return true; }
 
   virtual void Unlock() override {}
 
   virtual void FillInfo(TextureData::Info& aInfo) const override;
 
@@ -188,36 +188,36 @@ public:
     return mSizeY;
   }
 
   gfx::IntSize GetCbCrSize() const
   {
     return mSizeCbCr;
   }
 
-  uint32_t GetBitDepth() const
+  gfx::ColorDepth GetColorDepth() const
   {
-    return mBitDepth;
+    return mColorDepth;
   }
 
   YUVColorSpace GetYUVColorSpace() const
   {
     return mYUVColorSpace;
   }
 
   ID3D11Texture2D* GetD3D11Texture(size_t index) { return mD3D11Textures[index]; }
 
 protected:
    RefPtr<ID3D11Texture2D> mD3D11Textures[3];
    RefPtr<IDirect3DTexture9> mD3D9Textures[3];
    HANDLE mHandles[3];
    gfx::IntSize mSize;
    gfx::IntSize mSizeY;
    gfx::IntSize mSizeCbCr;
-   uint32_t mBitDepth;
+   gfx::ColorDepth mColorDepth;
    YUVColorSpace mYUVColorSpace;
 };
 
 /**
  * TextureSource that provides with the necessary APIs to be composited by a
  * CompositorD3D11.
  */
 class TextureSourceD3D11
@@ -410,19 +410,19 @@ public:
   virtual bool AcquireTextureSource(CompositableTextureSourceRef& aTexture) override;
 
   virtual void DeallocateDeviceData() override{}
 
   virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) override;
 
   virtual gfx::SurfaceFormat GetFormat() const override{ return gfx::SurfaceFormat::YUV; }
 
-  virtual YUVColorSpace GetYUVColorSpace() const override { return mYUVColorSpace; }
+  virtual gfx::ColorDepth GetColorDepth() const override { return mColorDepth; }
 
-  virtual uint32_t GetBitDepth() const override { return mBitDepth; }
+  virtual YUVColorSpace GetYUVColorSpace() const override { return mYUVColorSpace; }
 
   virtual bool Lock() override;
 
   virtual void Unlock() override;
 
   virtual gfx::IntSize GetSize() const override { return mSize; }
 
   virtual already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override
@@ -457,17 +457,17 @@ protected:
 
   RefPtr<ID3D11Texture2D> mTextures[3];
   RefPtr<DataTextureSourceD3D11> mTextureSources[3];
 
   gfx::IntSize mSize;
   gfx::IntSize mSizeCbCr;
   WindowsHandle mHandles[3];
   bool mIsLocked;
-  uint32_t mBitDepth;
+  gfx::ColorDepth mColorDepth;
   YUVColorSpace mYUVColorSpace;
 };
 
 class CompositingRenderTargetD3D11 : public CompositingRenderTarget,
                                      public TextureSourceD3D11
 {
 public:
   CompositingRenderTargetD3D11(ID3D11Texture2D* aTexture,

--- a/gfx/layers/ipc/LayersSurfaces.ipdlh
+++ b/gfx/layers/ipc/LayersSurfaces.ipdlh
@@ -4,16 +4,17 @@
 
 using struct gfxPoint from "gfxPoint.h";
 using nsIntRegion from "nsRegion.h";
 using struct mozilla::layers::SurfaceDescriptorX11 from "gfxipc/ShadowLayerUtils.h";
 using mozilla::StereoMode from "ImageTypes.h";
 using mozilla::YUVColorSpace from "ImageTypes.h";
 using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
 using mozilla::WindowsHandle from "ipc/IPCMessageUtils.h";
+using mozilla::gfx::ColorDepth from "mozilla/gfx/Types.h";
 using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
 using mozilla::gfx::IntRect from "mozilla/gfx/Rect.h";
 using mozilla::gfx::IntSize from "mozilla/gfx/Point.h";
 using mozilla::ipc::SharedMemoryBasic::Handle from "mozilla/ipc/SharedMemoryBasic.h";
 using gfxImageFormat from "gfxTypes.h";
 
 namespace mozilla {
 namespace layers {
@@ -47,17 +48,17 @@ struct SurfaceDescriptorD3D10 {
 
 struct SurfaceDescriptorDXGIYCbCr {
   WindowsHandle handleY;
   WindowsHandle handleCb;
   WindowsHandle handleCr;
   IntSize size;
   IntSize sizeY;
   IntSize sizeCbCr;
-  uint32_t bitDepth;
+  ColorDepth colorDepth;
   YUVColorSpace yUVColorSpace;
 };
 
 struct SurfaceDescriptorMacIOSurface {
   uint32_t surfaceId;
   double scaleFactor;
   bool isOpaque;
 };
@@ -107,18 +108,18 @@ struct YCbCrDescriptor {
   IntSize ySize;
   uint32_t yStride;
   IntSize cbCrSize;
   uint32_t cbCrStride;
   uint32_t yOffset;
   uint32_t cbOffset;
   uint32_t crOffset;
   StereoMode stereoMode;
+  ColorDepth colorDepth;
   YUVColorSpace yUVColorSpace;
-  uint32_t bitDepth;
   bool hasIntermediateBuffer;
 };
 
 union BufferDescriptor {
   RGBDescriptor;
   YCbCrDescriptor;
 };
 

--- a/gfx/layers/ipc/SharedPlanarYCbCrImage.cpp
+++ b/gfx/layers/ipc/SharedPlanarYCbCrImage.cpp
@@ -119,27 +119,27 @@ SharedPlanarYCbCrImage::AdoptData(const 
     std::max(aData.mYSize.width,
              std::max(aData.mYSize.height,
                       std::max(aData.mCbCrSize.width, aData.mCbCrSize.height))) <= fwd->GetMaxTextureSize();
   bool hasIntermediateBuffer = ComputeHasIntermediateBuffer(
     gfx::SurfaceFormat::YUV, fwd->GetCompositorBackendType(),
     supportsTextureDirectMapping);
 
   static_cast<BufferTextureData*>(mTextureClient->GetInternalData())
-    ->SetDesciptor(YCbCrDescriptor(aData.mYSize,
-                                   aData.mYStride,
-                                   aData.mCbCrSize,
-                                   aData.mCbCrStride,
-                                   yOffset,
-                                   cbOffset,
-                                   crOffset,
-                                   aData.mStereoMode,
-                                   aData.mYUVColorSpace,
-                                   aData.mBitDepth,
-                                   hasIntermediateBuffer));
+    ->SetDescriptor(YCbCrDescriptor(aData.mYSize,
+                                    aData.mYStride,
+                                    aData.mCbCrSize,
+                                    aData.mCbCrStride,
+                                    yOffset,
+                                    cbOffset,
+                                    crOffset,
+                                    aData.mStereoMode,
+                                    aData.mColorDepth,
+                                    aData.mYUVColorSpace,
+                                    hasIntermediateBuffer));
 
   return true;
 }
 
 bool
 SharedPlanarYCbCrImage::IsValid() const
 {
   return mTextureClient && mTextureClient->IsValid();
@@ -186,17 +186,17 @@ SharedPlanarYCbCrImage::Allocate(PlanarY
   mData.mCrChannel = aData.mCrChannel;
   mData.mYSize = aData.mYSize;
   mData.mCbCrSize = aData.mCbCrSize;
   mData.mPicX = aData.mPicX;
   mData.mPicY = aData.mPicY;
   mData.mPicSize = aData.mPicSize;
   mData.mStereoMode = aData.mStereoMode;
   mData.mYUVColorSpace = aData.mYUVColorSpace;
-  mData.mBitDepth = aData.mBitDepth;
+  mData.mColorDepth = aData.mColorDepth;
   // those members are not always equal to aData's, due to potentially different
   // packing.
   mData.mYSkip = 0;
   mData.mCbSkip = 0;
   mData.mCrSkip = 0;
   mData.mYStride = aData.mYStride;
   mData.mCbCrStride = aData.mCbCrStride;
 

--- a/gfx/layers/mlgpu/MLGDevice.cpp
+++ b/gfx/layers/mlgpu/MLGDevice.cpp
@@ -290,33 +290,32 @@ MLGDevice::GetBufferForColorSpace(YUVCol
     return nullptr;
   }
 
   mColorSpaceBuffers[aColorSpace] = resource;
   return resource;
 }
 
 RefPtr<MLGBuffer>
-MLGDevice::GetBufferForBitDepthCoefficient(uint8_t aBitDepth)
+MLGDevice::GetBufferForColorDepthCoefficient(ColorDepth aColorDepth)
 {
-  ColorDepth depth = ColorDepthForAlphaBitDepth(aBitDepth);
-  if (mColorDepthBuffers[depth]) {
-    return mColorDepthBuffers[depth];
+  if (mColorDepthBuffers[aColorDepth]) {
+    return mColorDepthBuffers[aColorDepth];
   }
 
-  YCbCrBitDepthConstants buffer;
-  buffer.coefficient = gfx::RescalingFactorForAlphaBitDepth(aBitDepth);
+  YCbCrColorDepthConstants buffer;
+  buffer.coefficient = gfx::RescalingFactorForColorDepth(aColorDepth);
 
   RefPtr<MLGBuffer> resource = CreateBuffer(
     MLGBufferType::Constant, sizeof(buffer), MLGUsage::Immutable, &buffer);
   if (!resource) {
     return nullptr;
   }
 
-  mColorDepthBuffers[depth] = resource;
+  mColorDepthBuffers[aColorDepth] = resource;
   return resource;
 }
 
 bool
 MLGDevice::Synchronize()
 {
   return true;
 }

--- a/gfx/layers/mlgpu/MLGDevice.h
+++ b/gfx/layers/mlgpu/MLGDevice.h
@@ -357,17 +357,18 @@ public:
   void SetPSTexture(uint32_t aSlot, TextureSource* aSource);
   void SetSamplerMode(uint32_t aIndex, gfx::SamplingFilter aFilter);
 
   // This creates or returns a previously created constant buffer, containing
   // a YCbCrShaderConstants instance.
   RefPtr<MLGBuffer> GetBufferForColorSpace(YUVColorSpace aColorSpace);
   // This creates or returns a previously created constant buffer, containing
   // a YCbCrBitDepthConstants instance.
-  RefPtr<MLGBuffer> GetBufferForBitDepthCoefficient(uint8_t aBitDepth);
+  RefPtr<MLGBuffer> GetBufferForColorDepthCoefficient(
+    gfx::ColorDepth aColorDepth);
 
   // A shared buffer that can be used to build VertexBufferSections.
   SharedVertexBuffer* GetSharedVertexBuffer() {
     return mSharedVertexBuffer.get();
   }
   // A shared buffer that can be used to build ConstantBufferSections. Intended
   // to be used with vertex shaders.
   SharedConstantBuffer* GetSharedVSBuffer() {
@@ -489,17 +490,17 @@ private:
   UniquePtr<BufferCache> mConstantBufferCache;
 
   nsCString mFailureId;
   nsCString mFailureMessage;
   bool mInitialized;
 
   typedef EnumeratedArray<YUVColorSpace, YUVColorSpace::UNKNOWN, RefPtr<MLGBuffer>> ColorSpaceArray;
   ColorSpaceArray mColorSpaceBuffers;
-  typedef EnumeratedArray<gfx::ColorDepth, gfx::ColorDepth::MAX, RefPtr<MLGBuffer>> ColorDepthArray;
+  typedef EnumeratedArray<gfx::ColorDepth, gfx::ColorDepth::UNKNOWN, RefPtr<MLGBuffer>> ColorDepthArray;
   ColorDepthArray mColorDepthBuffers;
 
 protected:
   bool mIsValid;
   bool mCanUseClearView;
   bool mCanUseConstantBufferOffsetBinding;
   size_t mMaxConstantBufferBindSize;
 

--- a/gfx/layers/mlgpu/RenderPassMLGPU.cpp
+++ b/gfx/layers/mlgpu/RenderPassMLGPU.cpp
@@ -814,17 +814,17 @@ VideoRenderPass::SetupPipeline()
   MOZ_ASSERT(colorSpace != YUVColorSpace::UNKNOWN);
 
   RefPtr<MLGBuffer> ps1 = mDevice->GetBufferForColorSpace(colorSpace);
   if (!ps1) {
     return;
   }
 
   RefPtr<MLGBuffer> ps2 =
-    mDevice->GetBufferForBitDepthCoefficient(mHost->GetBitDepth());
+    mDevice->GetBufferForColorDepthCoefficient(mHost->GetColorDepth());
   if (!ps2) {
     return;
   }
 
   if (mGeometry == GeometryMode::UnitQuad) {
     mDevice->SetVertexShader(VertexShaderID::TexturedQuad);
   } else {
     mDevice->SetVertexShader(VertexShaderID::TexturedVertex);

--- a/gfx/layers/mlgpu/ShaderDefinitionsMLGPU.h
+++ b/gfx/layers/mlgpu/ShaderDefinitionsMLGPU.h
@@ -87,17 +87,17 @@ struct MaskInformation
   uint32_t hasMask;
   uint32_t padding[2];
 };
 
 struct YCbCrShaderConstants {
   float yuvColorMatrix[3][4];
 };
 
-struct YCbCrBitDepthConstants {
+struct YCbCrColorDepthConstants {
   float coefficient;
   uint32_t padding[3];
 };
 
 struct BlendVertexShaderConstants {
   float backdropTransform[4][4];
 };
 

--- a/gfx/layers/opengl/CompositorOGL.cpp
+++ b/gfx/layers/opengl/CompositorOGL.cpp
@@ -983,17 +983,17 @@ CompositorOGL::GetShaderConfigFor(Effect
   case EffectTypes::SOLID_COLOR:
     config.SetRenderColor(true);
     break;
   case EffectTypes::YCBCR:
   {
     config.SetYCbCr(true);
     EffectYCbCr* effectYCbCr = static_cast<EffectYCbCr*>(aEffect);
     config.SetColorMultiplier(
-      RescalingFactorForAlphaBitDepth(effectYCbCr->mBitDepth));
+      RescalingFactorForColorDepth(effectYCbCr->mColorDepth));
     config.SetTextureTarget(
       effectYCbCr->mTexture->AsSourceOGL()->GetTextureTarget());
     break;
   }
   case EffectTypes::NV12:
     config.SetNV12(true);
     config.SetTextureTarget(LOCAL_GL_TEXTURE_RECTANGLE_ARB);
     break;
@@ -1481,16 +1481,17 @@ CompositorOGL::DrawGeometry(const Geomet
         BindMaskForProgram(program, sourceMask, LOCAL_GL_TEXTURE1, maskQuadTransform);
       }
       if (mixBlendBackdrop) {
         BindBackdrop(program, mixBlendBackdrop, LOCAL_GL_TEXTURE2);
       }
 
       BindAndDrawGeometryWithTextureRect(program, aGeometry,
                                          texturedEffect->mTextureCoords, source);
+      source->AsSourceOGL()->MaybeFenceTexture();
     }
     break;
   case EffectTypes::YCBCR: {
       EffectYCbCr* effectYCbCr =
         static_cast<EffectYCbCr*>(aEffectChain.mPrimaryEffect.get());
       TextureSource* sourceYCbCr = effectYCbCr->mTexture;
       const int Y = 0, Cb = 1, Cr = 2;
       TextureSourceOGL* sourceY =  sourceYCbCr->GetSubSource(Y)->AsSourceOGL();
@@ -1521,16 +1522,19 @@ CompositorOGL::DrawGeometry(const Geomet
       if (mixBlendBackdrop) {
         BindBackdrop(program, mixBlendBackdrop, LOCAL_GL_TEXTURE4);
       }
       didSetBlendMode = SetBlendMode(gl(), blendMode);
       BindAndDrawGeometryWithTextureRect(program,
                                          aGeometry,
                                          effectYCbCr->mTextureCoords,
                                          sourceYCbCr->GetSubSource(Y));
+      sourceY->MaybeFenceTexture();
+      sourceCb->MaybeFenceTexture();
+      sourceCr->MaybeFenceTexture();
     }
     break;
   case EffectTypes::NV12: {
       EffectNV12* effectNV12 =
         static_cast<EffectNV12*>(aEffectChain.mPrimaryEffect.get());
       TextureSource* sourceNV12 = effectNV12->mTexture;
       const int Y = 0, CbCr = 1;
       TextureSourceOGL* sourceY =  sourceNV12->GetSubSource(Y)->AsSourceOGL();
@@ -1558,16 +1562,18 @@ CompositorOGL::DrawGeometry(const Geomet
       if (mixBlendBackdrop) {
         BindBackdrop(program, mixBlendBackdrop, LOCAL_GL_TEXTURE3);
       }
       didSetBlendMode = SetBlendMode(gl(), blendMode);
       BindAndDrawGeometryWithTextureRect(program,
                                          aGeometry,
                                          effectNV12->mTextureCoords,
                                          sourceNV12->GetSubSource(Y));
+      sourceY->MaybeFenceTexture();
+      sourceCbCr->MaybeFenceTexture();
     }
     break;
   case EffectTypes::RENDER_TARGET: {
       EffectRenderTarget* effectRenderTarget =
         static_cast<EffectRenderTarget*>(aEffectChain.mPrimaryEffect.get());
       RefPtr<CompositingRenderTargetOGL> surface
         = static_cast<CompositingRenderTargetOGL*>(effectRenderTarget->mRenderTarget.get());
 
@@ -1640,16 +1646,19 @@ CompositorOGL::DrawGeometry(const Geomet
       program->SetTexturePass2(true);
       BindAndDrawGeometryWithTextureRect(program,
                                          aGeometry,
                                          effectComponentAlpha->mTextureCoords,
                                          effectComponentAlpha->mOnBlack);
 
       mGLContext->fBlendFuncSeparate(LOCAL_GL_ONE, LOCAL_GL_ONE_MINUS_SRC_ALPHA,
                                      LOCAL_GL_ONE, LOCAL_GL_ONE_MINUS_SRC_ALPHA);
+
+      sourceOnBlack->MaybeFenceTexture();
+      sourceOnWhite->MaybeFenceTexture();
     }
     break;
   default:
     MOZ_ASSERT(false, "Unhandled effect type");
     break;
   }
 
   if (didSetBlendMode) {
@@ -1932,33 +1941,33 @@ CompositorOGL::CreateDataTextureSourceAr
   uint8_t* buf = bufferTexture->GetBuffer();
   const BufferDescriptor& buffDesc = bufferTexture->GetBufferDescriptor();
   const YCbCrDescriptor& desc = buffDesc.get_YCbCrDescriptor();
 
   RefPtr<gfx::DataSourceSurface> tempY =
     gfx::Factory::CreateWrappingDataSourceSurface(ImageDataSerializer::GetYChannel(buf, desc),
                                                   desc.yStride(),
                                                   desc.ySize(),
-                                                  SurfaceFormatForAlphaBitDepth(desc.bitDepth()));
+                                                  SurfaceFormatForColorDepth(desc.colorDepth()));
   if (!tempY) {
     return nullptr;
   }
   RefPtr<gfx::DataSourceSurface> tempCb =
     gfx::Factory::CreateWrappingDataSourceSurface(ImageDataSerializer::GetCbChannel(buf, desc),
                                                   desc.cbCrStride(),
                                                   desc.cbCrSize(),
-                                                  SurfaceFormatForAlphaBitDepth(desc.bitDepth()));
+                                                  SurfaceFormatForColorDepth(desc.colorDepth()));
   if (!tempCb) {
     return nullptr;
   }
   RefPtr<gfx::DataSourceSurface> tempCr =
     gfx::Factory::CreateWrappingDataSourceSurface(ImageDataSerializer::GetCrChannel(buf, desc),
                                                   desc.cbCrStride(),
                                                   desc.cbCrSize(),
-                                                  SurfaceFormatForAlphaBitDepth(desc.bitDepth()));
+                                                  SurfaceFormatForColorDepth(desc.colorDepth()));
   if (!tempCr) {
     return nullptr;
   }
 
   RefPtr<DirectMapTextureSource> srcY = new DirectMapTextureSource(this, tempY);
   RefPtr<DirectMapTextureSource> srcU = new DirectMapTextureSource(this, tempCb);
   RefPtr<DirectMapTextureSource> srcV = new DirectMapTextureSource(this, tempCr);
 

--- a/gfx/layers/opengl/TextureHostOGL.cpp
+++ b/gfx/layers/opengl/TextureHostOGL.cpp
@@ -314,53 +314,81 @@ GLTextureSource::IsValid() const
 
 DirectMapTextureSource::DirectMapTextureSource(TextureSourceProvider* aProvider,
                                                gfx::DataSourceSurface* aSurface)
   : GLTextureSource(aProvider,
                     0,
                     LOCAL_GL_TEXTURE_RECTANGLE_ARB,
                     aSurface->GetSize(),
                     aSurface->GetFormat())
+  , mSync(0)
 {
   MOZ_ASSERT(aSurface);
 
   UpdateInternal(aSurface, nullptr, nullptr, true);
 }
 
+DirectMapTextureSource::~DirectMapTextureSource()
+{
+  if (!mSync || !gl() || !gl()->MakeCurrent() || gl()->IsDestroyed()) {
+    return;
+  }
+
+  gl()->fDeleteSync(mSync);
+  mSync = 0;
+}
+
 bool
 DirectMapTextureSource::Update(gfx::DataSourceSurface* aSurface,
                                nsIntRegion* aDestRegion,
                                gfx::IntPoint* aSrcOffset)
 {
   if (!aSurface) {
     return false;
   }
 
   return UpdateInternal(aSurface, aDestRegion, aSrcOffset, false);
 }
 
+void
+DirectMapTextureSource::MaybeFenceTexture()
+{
+  if (!gl() ||
+      !gl()->MakeCurrent() ||
+      gl()->IsDestroyed()) {
+    return;
+  }
+
+  if (mSync) {
+    gl()->fDeleteSync(mSync);
+  }
+  mSync = gl()->fFenceSync(LOCAL_GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+}
+
+
 bool
 DirectMapTextureSource::Sync(bool aBlocking)
 {
-  if (!gl() || !gl()->MakeCurrent()) {
+  if (!gl() || !gl()->MakeCurrent() || gl()->IsDestroyed()) {
     // We use this function to decide whether we can unlock the texture
     // and clean it up. If we return false here and for whatever reason
     // the context is absent or invalid, the compositor will keep a
     // reference to this texture forever.
     return true;
   }
 
-  if (!gl()->IsDestroyed()) {
-    if (aBlocking) {
-      gl()->fFinishObjectAPPLE(LOCAL_GL_TEXTURE, mTextureHandle);
-    } else {
-      return gl()->fTestObjectAPPLE(LOCAL_GL_TEXTURE, mTextureHandle);
-    }
+  if (!mSync) {
+    return false;
   }
-  return true;
+
+  GLenum waitResult = gl()->fClientWaitSync(mSync,
+                                            LOCAL_GL_SYNC_FLUSH_COMMANDS_BIT,
+                                            aBlocking ? LOCAL_GL_TIMEOUT_IGNORED : 0);
+  return waitResult == LOCAL_GL_ALREADY_SIGNALED ||
+         waitResult == LOCAL_GL_CONDITION_SATISFIED; 
 }
 
 bool
 DirectMapTextureSource::UpdateInternal(gfx::DataSourceSurface* aSurface,
                                        nsIntRegion* aDestRegion,
                                        gfx::IntPoint* aSrcOffset,
                                        bool aInit)
 {
@@ -404,16 +432,21 @@ DirectMapTextureSource::UpdateInternal(g
                                        mTextureHandle,
                                        aSurface->GetSize(),
                                        nullptr,
                                        aInit,
                                        srcPoint,
                                        LOCAL_GL_TEXTURE0,
                                        LOCAL_GL_TEXTURE_RECTANGLE_ARB);
 
+  if (mSync) {
+    gl()->fDeleteSync(mSync);
+    mSync = 0;
+  }
+
   gl()->fPixelStorei(LOCAL_GL_UNPACK_CLIENT_STORAGE_APPLE, LOCAL_GL_FALSE);
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 // SurfaceTextureHost
 

--- a/gfx/layers/opengl/TextureHostOGL.h
+++ b/gfx/layers/opengl/TextureHostOGL.h
@@ -87,16 +87,24 @@ public:
     , mHasCachedSamplingFilter(false)
   {}
 
   virtual bool IsValid() const = 0;
 
   virtual void BindTexture(GLenum aTextureUnit,
                            gfx::SamplingFilter aSamplingFilter) = 0;
 
+  // To be overridden in textures that need this. This method will be called
+  // when the compositor has used the texture to draw. This allows us to set
+  // a fence with glFenceSync which we can wait on later to ensure the GPU
+  // is done with the draw calls using that texture. We would like to be able
+  // to simply use glFinishObjectAPPLE, but this returns earlier than
+  // expected with nvidia drivers.
+  virtual void MaybeFenceTexture() {}
+
   virtual gfx::IntSize GetSize() const = 0;
 
   virtual GLenum GetTextureTarget() const { return LOCAL_GL_TEXTURE_2D; }
 
   virtual gfx::SurfaceFormat GetFormat() const = 0;
 
   virtual GLenum GetWrapMode() const = 0;
 
@@ -293,33 +301,38 @@ protected:
 // should be alive until the ~ClientStorageTextureSource(). And if we try to
 // update the surface we mapped before, we need to call Sync() to make sure
 // the surface is not used by compositor.
 class DirectMapTextureSource : public GLTextureSource
 {
 public:
   DirectMapTextureSource(TextureSourceProvider* aProvider,
                          gfx::DataSourceSurface* aSurface);
+  ~DirectMapTextureSource();
 
   virtual bool Update(gfx::DataSourceSurface* aSurface,
                       nsIntRegion* aDestRegion = nullptr,
                       gfx::IntPoint* aSrcOffset = nullptr) override;
 
   virtual bool IsDirectMap() override { return true; }
 
   // If aBlocking is false, check if this texture is no longer being used
   // by the GPU - if aBlocking is true, this will block until the GPU is
   // done with it.
   virtual bool Sync(bool aBlocking) override;
 
+  virtual void MaybeFenceTexture() override;
+
 private:
   bool UpdateInternal(gfx::DataSourceSurface* aSurface,
                       nsIntRegion* aDestRegion,
                       gfx::IntPoint* aSrcOffset,
                       bool aInit);
+
+  GLsync mSync;
 };
 
 class GLTextureHost : public TextureHost
 {
 public:
   GLTextureHost(TextureFlags aFlags,
                 GLuint aTextureHandle,
                 GLenum aTarget,

--- a/gfx/layers/wr/AsyncImagePipelineManager.cpp
+++ b/gfx/layers/wr/AsyncImagePipelineManager.cpp
@@ -376,17 +376,17 @@ AsyncImagePipelineManager::ApplyAsyncIma
 
   aPipeline->mIsChanged = false;
 
   wr::LayoutSize contentSize { aPipeline->mScBounds.Width(), aPipeline->mScBounds.Height() };
   wr::DisplayListBuilder builder(aPipelineId, contentSize);
 
   float opacity = 1.0f;
   Maybe<wr::WrClipId> referenceFrameId = builder.PushStackingContext(
-    wr::ToLayoutRect(aPipeline->mScBounds),
+    wr::ToRoundedLayoutRect(aPipeline->mScBounds),
     nullptr,
     nullptr,
     &opacity,
     aPipeline->mScTransform.IsIdentity() ? nullptr : &aPipeline->mScTransform,
     wr::TransformStyle::Flat,
     nullptr,
     aPipeline->mMixBlendMode,
     nsTArray<wr::WrFilterOp>(),
@@ -399,25 +399,25 @@ AsyncImagePipelineManager::ApplyAsyncIma
     if (aPipeline->mScaleToSize.isSome()) {
       rect = LayoutDeviceRect(0, 0, aPipeline->mScaleToSize.value().width, aPipeline->mScaleToSize.value().height);
     }
 
     if (aPipeline->mUseExternalImage) {
       MOZ_ASSERT(aPipeline->mCurrentTexture->AsWebRenderTextureHost());
       Range<wr::ImageKey> range_keys(&keys[0], keys.Length());
       aPipeline->mCurrentTexture->PushDisplayItems(builder,
-                                                  wr::ToLayoutRect(rect),
-                                                  wr::ToLayoutRect(rect),
+                                                  wr::ToRoundedLayoutRect(rect),
+                                                  wr::ToRoundedLayoutRect(rect),
                                                   aPipeline->mFilter,
                                                   range_keys);
       HoldExternalImage(aPipelineId, aEpoch, aPipeline->mCurrentTexture->AsWebRenderTextureHost());
     } else {
       MOZ_ASSERT(keys.Length() == 1);
-      builder.PushImage(wr::ToLayoutRect(rect),
-                        wr::ToLayoutRect(rect),
+      builder.PushImage(wr::ToRoundedLayoutRect(rect),
+                        wr::ToRoundedLayoutRect(rect),
                         true,
                         aPipeline->mFilter,
                         keys[0]);
     }
   }
 
   builder.PopStackingContext(referenceFrameId.isSome());
 

--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -669,35 +669,35 @@ struct DIGroup
     if (empty) {
       ClearImageKey(aWrManager, true);
       return;
     }
 
     PaintItemRange(aGrouper, aStartItem, aEndItem, context, recorder);
 
     // XXX: set this correctly perhaps using aItem->GetOpaqueRegion(aDisplayListBuilder, &snapped).Contains(paintBounds);?
-    bool isOpaque = false;
+    wr::OpacityType opacity = wr::OpacityType::HasAlphaChannel;
 
     TakeExternalSurfaces(recorder, mExternalSurfaces, aWrManager, aResources);
     bool hasItems = recorder->Finish();
     GP("%d Finish\n", hasItems);
     Range<uint8_t> bytes((uint8_t*)recorder->mOutputStream.mData, recorder->mOutputStream.mLength);
     if (!mKey) {
       if (!hasItems) // we don't want to send a new image that doesn't have any items in it
         return;
       wr::ImageKey key = aWrManager->WrBridge()->GetNextImageKey();
       GP("No previous key making new one %d\n", key.mHandle);
-      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), isOpaque);
+      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), opacity);
       MOZ_RELEASE_ASSERT(bytes.length() > sizeof(size_t));
       if (!aResources.AddBlobImage(key, descriptor, bytes)) {
         return;
       }
       mKey = Some(key);
     } else {
-      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), isOpaque);
+      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), opacity);
       auto bottomRight = mInvalidRect.BottomRight();
       GP("check invalid %d %d - %d %d\n", bottomRight.x, bottomRight.y, dtSize.width, dtSize.height);
       MOZ_RELEASE_ASSERT(bottomRight.x <= dtSize.width && bottomRight.y <= dtSize.height);
       GP("Update Blob %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);
       if (!aResources.UpdateBlobImage(mKey.value(), descriptor, bytes, ViewAs<ImagePixel>(mInvalidRect))) {
         return;
       }
     }
@@ -1886,17 +1886,21 @@ WebRenderCommandBuilder::GenerateFallbac
     nsAutoPtr<nsDisplayItemGeometry> newGeometry;
     newGeometry = aItem->AllocateGeometry(aDisplayListBuilder);
     fallbackData->SetGeometry(std::move(newGeometry));
 
     gfx::SurfaceFormat format = aItem->GetType() == DisplayItemType::TYPE_MASK ?
                                                       gfx::SurfaceFormat::A8 : gfx::SurfaceFormat::B8G8R8A8;
     if (useBlobImage) {
       bool snapped;
-      bool isOpaque = aItem->GetOpaqueRegion(aDisplayListBuilder, &snapped).Contains(paintBounds);
+      wr::OpacityType opacity =
+        aItem->GetOpaqueRegion(aDisplayListBuilder, &snapped)
+            .Contains(paintBounds)
+          ? wr::OpacityType::Opaque
+          : wr::OpacityType::HasAlphaChannel;
       std::vector<RefPtr<ScaledFont>> fonts;
 
       RefPtr<WebRenderDrawEventRecorder> recorder =
         MakeAndAddRef<WebRenderDrawEventRecorder>([&] (MemStream &aStream, std::vector<RefPtr<ScaledFont>> &aScaledFonts) {
           size_t count = aScaledFonts.size();
           aStream.write((const char*)&count, sizeof(count));
           for (auto& scaled : aScaledFonts) {
             BlobFont font = {
@@ -1917,17 +1921,17 @@ WebRenderCommandBuilder::GenerateFallbac
                                                  fallbackData->mBasicLayerManager, scale, highlight);
       recorder->FlushItem(IntRect(0, 0, paintSize.width, paintSize.height));
       TakeExternalSurfaces(recorder, fallbackData->mExternalSurfaces, mManager, aResources);
       recorder->Finish();
 
       if (isInvalidated) {
         Range<uint8_t> bytes((uint8_t *)recorder->mOutputStream.mData, recorder->mOutputStream.mLength);
         wr::ImageKey key = mManager->WrBridge()->GetNextImageKey();
-        wr::ImageDescriptor descriptor(dtSize.ToUnknownSize(), 0, dt->GetFormat(), isOpaque);
+        wr::ImageDescriptor descriptor(dtSize.ToUnknownSize(), 0, dt->GetFormat(), opacity);
         if (!aResources.AddBlobImage(key, descriptor, bytes)) {
           return nullptr;
         }
         fallbackData->SetKey(key);
         fallbackData->SetFonts(fonts);
       } else {
         // If there is no invalidation region and we don't have a image key,
         // it means we don't need to push image for the item.

--- a/gfx/layers/wr/WebRenderMessageUtils.h
+++ b/gfx/layers/wr/WebRenderMessageUtils.h
@@ -44,27 +44,27 @@ struct ParamTraits<mozilla::wr::ImageDes
 
   static void
   Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.format);
     WriteParam(aMsg, aParam.width);
     WriteParam(aMsg, aParam.height);
     WriteParam(aMsg, aParam.stride);
-    WriteParam(aMsg, aParam.is_opaque);
+    WriteParam(aMsg, aParam.opacity);
   }
 
   static bool
   Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
   {
     return ReadParam(aMsg, aIter, &aResult->format)
         && ReadParam(aMsg, aIter, &aResult->width)
         && ReadParam(aMsg, aIter, &aResult->height)
         && ReadParam(aMsg, aIter, &aResult->stride)
-        && ReadParam(aMsg, aIter, &aResult->is_opaque);
+        && ReadParam(aMsg, aIter, &aResult->opacity);
   }
 };
 
 template<>
 struct ParamTraits<mozilla::wr::IdNamespace>
   : public PlainOldDataSerializer<mozilla::wr::IdNamespace>
 {
 };
@@ -178,11 +178,17 @@ struct ParamTraits<mozilla::wr::WebRende
 };
 
 template<>
 struct ParamTraits<mozilla::wr::MemoryReport>
   : public PlainOldDataSerializer<mozilla::wr::MemoryReport>
 {
 };
 
+template<>
+struct ParamTraits<mozilla::wr::OpacityType>
+  : public PlainOldDataSerializer<mozilla::wr::OpacityType>
+{
+};
+
 } // namespace IPC
 
 #endif // GFX_WEBRENDERMESSAGEUTILS_H

--- a/gfx/tests/gtest/TestTextures.cpp
+++ b/gfx/tests/gtest/TestTextures.cpp
@@ -261,17 +261,17 @@ TEST(Layers, TextureYCbCrSerialization) 
   clientData.mCrChannel = crSurface->Data();
   clientData.mYSize = ySurface->GetSize();
   clientData.mPicSize = ySurface->GetSize();
   clientData.mCbCrSize = cbSurface->GetSize();
   clientData.mYStride = ySurface->Stride();
   clientData.mCbCrStride = cbSurface->Stride();
   clientData.mStereoMode = StereoMode::MONO;
   clientData.mYUVColorSpace = YUVColorSpace::BT601;
-  clientData.mBitDepth = 8;
+  clientData.mColorDepth = ColorDepth::COLOR_8;
   clientData.mYSkip = 0;
   clientData.mCbSkip = 0;
   clientData.mCrSkip = 0;
   clientData.mCrSkip = 0;
   clientData.mPicX = 0;
   clientData.mPicX = 0;
 
   uint32_t namespaceId = 1;
@@ -290,16 +290,23 @@ TEST(Layers, TextureYCbCrSerialization) 
     retry--;
   }
 
   // Skip this testing if IPDL connection is not ready
   if (!retry && !imageBridge->IPCOpen()) {
     return;
   }
 
-  RefPtr<TextureClient> client = TextureClient::CreateForYCbCr(imageBridge, clientData.mYSize, clientData.mYStride, clientData.mCbCrSize, clientData.mCbCrStride,
-                                                               StereoMode::MONO, YUVColorSpace::BT601,
-                                                               8, TextureFlags::DEALLOCATE_CLIENT);
+  RefPtr<TextureClient> client =
+    TextureClient::CreateForYCbCr(imageBridge,
+                                  clientData.mYSize,
+                                  clientData.mYStride,
+                                  clientData.mCbCrSize,
+                                  clientData.mCbCrStride,
+                                  StereoMode::MONO,
+                                  gfx::ColorDepth::COLOR_8,
+                                  YUVColorSpace::BT601,
+                                  TextureFlags::DEALLOCATE_CLIENT);
 
   TestTextureClientYCbCr(client, clientData);
 
   // XXX - Test more texture client types.
 }

--- a/gfx/tests/gtest/TextureHelper.h
+++ b/gfx/tests/gtest/TextureHelper.h
@@ -55,26 +55,26 @@ CreateYCbCrTextureClientWithBackend(Laye
   clientData.mStereoMode = StereoMode::MONO;
   clientData.mYSkip = 0;
   clientData.mCbSkip = 0;
   clientData.mCrSkip = 0;
   clientData.mCrSkip = 0;
   clientData.mPicX = 0;
   clientData.mPicX = 0;
 
-  // Create YCbCrTexture for basice backend.
+  // Create YCbCrTexture for basic backend.
   if (aLayersBackend == LayersBackend::LAYERS_BASIC) {
     return TextureClient::CreateForYCbCr(nullptr,
                                          clientData.mYSize,
                                          clientData.mYStride,
                                          clientData.mCbCrSize,
                                          clientData.mCbCrStride,
                                          StereoMode::MONO,
+                                         gfx::ColorDepth::COLOR_8,
                                          YUVColorSpace::BT601,
-                                         8,
                                          TextureFlags::DEALLOCATE_CLIENT);
   }
 
 #ifdef XP_WIN
   RefPtr<ID3D11Device> device = DeviceManagerDx::Get()->GetImageDevice();
 
   if (device && aLayersBackend == LayersBackend::LAYERS_D3D11) {
     DXGIYCbCrTextureAllocationHelper helper(clientData, TextureFlags::DEFAULT, device);

--- a/gfx/vr/VRDisplayHost.cpp
+++ b/gfx/vr/VRDisplayHost.cpp
@@ -203,40 +203,57 @@ VRDisplayHost::RemoveLayer(VRLayerParent
   vm->RefreshVRDisplays();
 }
 
 void
 VRDisplayHost::StartFrame()
 {
   AUTO_PROFILER_TRACING("VR", "GetSensorState");
 
+  TimeStamp now = TimeStamp::Now();
 #if defined(MOZ_WIDGET_ANDROID)
+  const TimeStamp lastFrameStart = mDisplayInfo.mLastFrameStart[mDisplayInfo.mFrameId % kVRMaxLatencyFrames];
   const bool isPresenting = mLastUpdateDisplayInfo.GetPresentingGroups() != 0;
-  double duration = mLastFrameStart.IsNull() ? 0.0 : (TimeStamp::Now() - mLastFrameStart).ToMilliseconds();
+  double duration = lastFrameStart.IsNull() ? 0.0 : (now - lastFrameStart).ToMilliseconds();
   /**
    * Do not start more VR frames until the last submitted frame is already processed.
    */
   if (isPresenting && mLastStartedFrame > 0 && mDisplayInfo.mDisplayState.mLastSubmittedFrameId < mLastStartedFrame && duration < (double)ANDROID_MAX_FRAME_DURATION) {
     return;
   }
 #endif // !defined(MOZ_WIDGET_ANDROID)
 
-  mLastFrameStart = TimeStamp::Now();
   ++mDisplayInfo.mFrameId;
-  mDisplayInfo.mLastSensorState[mDisplayInfo.mFrameId % kVRMaxLatencyFrames] = GetSensorState();
+  size_t bufferIndex = mDisplayInfo.mFrameId % kVRMaxLatencyFrames;
+  mDisplayInfo.mLastSensorState[bufferIndex] = GetSensorState();
+  mDisplayInfo.mLastFrameStart[bufferIndex] = now;
   mFrameStarted = true;
 #if defined(MOZ_WIDGET_ANDROID)
   mLastStartedFrame = mDisplayInfo.mFrameId;
 #endif // !defined(MOZ_WIDGET_ANDROID)  
 }
 
 void
 VRDisplayHost::NotifyVSync()
 {
   /**
+   * If this display isn't presenting, refresh the sensors and trigger
+   * VRDisplay.requestAnimationFrame at the normal 2d display refresh rate.
+   */
+  if (mDisplayInfo.mPresentingGroups == 0) {
+    VRManager *vm = VRManager::Get();
+    MOZ_ASSERT(vm);
+    vm->NotifyVRVsync(mDisplayInfo.mDisplayID);
+  }
+}
+
+void
+VRDisplayHost::CheckWatchDog()
+{
+  /**
    * We will trigger a new frame immediately after a successful frame texture
    * submission.  If content fails to call VRDisplay.submitFrame after
    * dom.vr.display.rafMaxDuration milliseconds has elapsed since the last
    * VRDisplay.requestAnimationFrame, we act as a "watchdog" and kick-off
    * a new VRDisplay.requestAnimationFrame to avoid a render loop stall and
    * to give content a chance to recover.
    *
    * If the lower level VR platform API's are rejecting submitted frames,
@@ -255,41 +272,54 @@ VRDisplayHost::NotifyVSync()
    * The slowest expected refresh rate for a VR display currently is an
    * Oculus CV1 when ASW (Asynchronous Space Warp) is enabled, at 45hz.
    * A dom.vr.display.rafMaxDuration value of 50 milliseconds results in a 20hz
    * rate, which avoids inadvertent triggering of the watchdog during
    * Oculus ASW even if every second frame is dropped.
    */
   bool bShouldStartFrame = false;
 
-  if (mDisplayInfo.mPresentingGroups == 0) {
-    // If this display isn't presenting, refresh the sensors and trigger
-    // VRDisplay.requestAnimationFrame at the normal 2d display refresh rate.
+  // If content fails to call VRDisplay.submitFrame, we must eventually
+  // time-out and trigger a new frame.
+  TimeStamp lastFrameStart = mDisplayInfo.mLastFrameStart[mDisplayInfo.mFrameId % kVRMaxLatencyFrames];
+  if (lastFrameStart.IsNull()) {
     bShouldStartFrame = true;
   } else {
-    // If content fails to call VRDisplay.submitFrame, we must eventually
-    // time-out and trigger a new frame.
-    if (mLastFrameStart.IsNull()) {
+    TimeDuration duration = TimeStamp::Now() - lastFrameStart;
+    if (duration.ToMilliseconds() > gfxPrefs::VRDisplayRafMaxDuration()) {
       bShouldStartFrame = true;
-    } else {
-      TimeDuration duration = TimeStamp::Now() - mLastFrameStart;
-      if (duration.ToMilliseconds() > gfxPrefs::VRDisplayRafMaxDuration()) {
-        bShouldStartFrame = true;
-      }
     }
   }
 
   if (bShouldStartFrame) {
     VRManager *vm = VRManager::Get();
     MOZ_ASSERT(vm);
     vm->NotifyVRVsync(mDisplayInfo.mDisplayID);
   }
 }
 
 void
+VRDisplayHost::Run1msTasks(double aDeltaTime)
+{
+ // To override in children
+}
+
+void
+VRDisplayHost::Run10msTasks()
+{
+  CheckWatchDog();
+}
+
+void
+VRDisplayHost::Run100msTasks()
+{
+  // to override in children
+}
+
+void
 VRDisplayHost::SubmitFrameInternal(const layers::SurfaceDescriptor &aTexture,
                                    uint64_t aFrameId,
                                    const gfx::Rect& aLeftEyeRect,
                                    const gfx::Rect& aRightEyeRect)
 {
 #if !defined(MOZ_WIDGET_ANDROID)
   MOZ_ASSERT(mSubmitThread->GetThread() == NS_GetCurrentThread());
 #endif // !defined(MOZ_WIDGET_ANDROID)

--- a/gfx/vr/VRDisplayHost.h
+++ b/gfx/vr/VRDisplayHost.h
@@ -40,16 +40,19 @@ public:
   void RemoveLayer(VRLayerParent* aLayer);
 
   virtual void ZeroSensor() = 0;
   virtual void StartPresentation() = 0;
   virtual void StopPresentation() = 0;
   virtual void StartVRNavigation();
   virtual void StopVRNavigation(const TimeDuration& aTimeout);
   void NotifyVSync();
+  virtual void Run1msTasks(double aDeltaTime);
+  virtual void Run10msTasks();
+  virtual void Run100msTasks();
 
   void StartFrame();
   void SubmitFrame(VRLayerParent* aLayer,
                    const layers::SurfaceDescriptor& aTexture,
                    uint64_t aFrameId,
                    const gfx::Rect& aLeftEyeRect,
                    const gfx::Rect& aRightEyeRect);
 
@@ -92,19 +95,19 @@ protected:
   virtual VRHMDSensorState GetSensorState() = 0;
 
   RefPtr<VRThread> mSubmitThread;
 private:
   void SubmitFrameInternal(const layers::SurfaceDescriptor& aTexture,
                            uint64_t aFrameId,
                            const gfx::Rect& aLeftEyeRect,
                            const gfx::Rect& aRightEyeRect);
+  void CheckWatchDog();
 
   VRDisplayInfo mLastUpdateDisplayInfo;
-  TimeStamp mLastFrameStart;
   bool mFrameStarted;
 #if defined(MOZ_WIDGET_ANDROID)
 protected:
   uint64_t mLastSubmittedFrameId;
   uint64_t mLastStartedFrame;
 #endif // defined(MOZ_WIDGET_ANDROID)
 
 #if defined(XP_WIN)

--- a/gfx/vr/VRManager.cpp
+++ b/gfx/vr/VRManager.cpp
@@ -40,34 +40,51 @@ using namespace mozilla::gfx;
 using namespace mozilla::layers;
 using namespace mozilla::gl;
 
 namespace mozilla {
 namespace gfx {
 
 static StaticRefPtr<VRManager> sVRManagerSingleton;
 
+ /**
+  * When VR content is active, we run the tasks at 1ms
+  * intervals, enabling multiple events to be processed
+  * per frame, such as haptic feedback pulses.
+  */
+const uint32_t kVRActiveTaskInterval = 1; // milliseconds
+
+ /**
+  * When VR content is inactive, we run the tasks at 100ms
+  * intervals, enabling VR display enumeration and
+  * presentation startup to be relatively responsive
+  * while not consuming unnecessary resources.
+  */
+const uint32_t kVRIdleTaskInterval = 100; // milliseconds
+
 /*static*/ void
 VRManager::ManagerInit()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   // TODO: We should make VRManager::ManagerInit
   // be called when entering VR content pages.
   if (sVRManagerSingleton == nullptr) {
     sVRManagerSingleton = new VRManager();
     ClearOnShutdown(&sVRManagerSingleton);
   }
 }
 
 VRManager::VRManager()
   : mInitialized(false)
+  , mAccumulator100ms(0.0f)
   , mVRDisplaysRequested(false)
   , mVRControllersRequested(false)
   , mVRServiceStarted(false)
+  , mTaskInterval(0)
 {
   MOZ_COUNT_CTOR(VRManager);
   MOZ_ASSERT(sVRManagerSingleton == nullptr);
 
   RefPtr<VRSystemManager> mgr;
 
   /**
    * We must add the VRDisplayManager's to mManagers in a careful order to
@@ -146,16 +163,17 @@ VRManager::~VRManager()
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!mInitialized);
   MOZ_COUNT_DTOR(VRManager);
 }
 
 void
 VRManager::Destroy()
 {
+  StopTasks();
   mVRDisplays.Clear();
   mVRControllers.Clear();
   for (uint32_t i = 0; i < mManagers.Length(); ++i) {
     mManagers[i]->Destroy();
   }
 #if defined(XP_WIN) || defined(XP_MACOSX) || (defined(XP_LINUX) && !defined(MOZ_WIDGET_ANDROID))
   if (mVRService) {
     mVRService->Stop();
@@ -190,16 +208,17 @@ VRManager::Shutdown()
   }
 #endif
   mVRServiceStarted = false;
 }
 
 void
 VRManager::Init()
 {
+  StartTasks();
   mInitialized = true;
 }
 
 /* static */VRManager*
 VRManager::Get()
 {
   MOZ_ASSERT(sVRManagerSingleton != nullptr);
 
@@ -247,33 +266,212 @@ VRManager::UpdateRequestedDevices()
  * This must be called even when no WebVR site is active.
  * If we don't have a 2d display attached to the system, we can call this
  * at the VR display's native refresh rate.
  **/
 void
 VRManager::NotifyVsync(const TimeStamp& aVsyncTimestamp)
 {
   MOZ_ASSERT(VRListenerThreadHolder::IsInVRListenerThread());
-  UpdateRequestedDevices();
 
   for (const auto& manager : mManagers) {
     manager->NotifyVSync();
   }
+}
+
+void
+VRManager::StartTasks()
+{
+  MOZ_ASSERT(VRListenerThread());
+  if (!mTaskTimer) {
+    mTaskInterval = GetOptimalTaskInterval();
+    mTaskTimer = NS_NewTimer();
+    mTaskTimer->SetTarget(VRListenerThreadHolder::Loop()->SerialEventTarget());
+    mTaskTimer->InitWithNamedFuncCallback(
+      TaskTimerCallback,
+      this,
+      mTaskInterval,
+      nsITimer::TYPE_REPEATING_PRECISE_CAN_SKIP,
+      "VRManager::TaskTimerCallback");
+  }
+}
+
+void
+VRManager::StopTasks()
+{
+  if (mTaskTimer) {
+    MOZ_ASSERT(VRListenerThread());
+    mTaskTimer->Cancel();
+    mTaskTimer = nullptr;
+  }
+}
+
+/*static*/ void
+VRManager::StopVRListenerThreadTasks()
+{
+  if (sVRManagerSingleton) {
+    sVRManagerSingleton->StopTasks();
+  }
+}
+
+/*static*/ void
+VRManager::TaskTimerCallback(nsITimer* aTimer, void* aClosure)
+{
+  /**
+   * It is safe to use the pointer passed in aClosure to reference the
+   * VRManager object as the timer is canceled in VRManager::Destroy.
+   * VRManager::Destroy set mInitialized to false, which is asserted
+   * in the VRManager destructor, guaranteeing that this functions
+   * runs if and only if the VRManager object is valid.
+   */
+  VRManager* self = static_cast<VRManager*>(aClosure);
+  self->RunTasks();
+}
+
+void
+VRManager::RunTasks()
+{
+  MOZ_ASSERT(VRListenerThreadHolder::IsInVRListenerThread());
+
+  // Will be called once every 1ms when a VR presentation
+  // is active or once per vsync when a VR presentation is
+  // not active.
+
+  TimeStamp now = TimeStamp::Now();
+  double lastTickMs = mAccumulator100ms;
+  double deltaTime = 0.0f;
+  if (!mLastTickTime.IsNull()) {
+    deltaTime = (now - mLastTickTime).ToMilliseconds();
+  }
+  mAccumulator100ms += deltaTime;
+  mLastTickTime = now;
+
+  if (deltaTime > 0.0f && floor(mAccumulator100ms) != floor(lastTickMs)) {
+    // Even if more than 1 ms has passed, we will only
+    // execute Run1msTasks() once.
+    Run1msTasks(deltaTime);
+  }
+
+  if (floor(mAccumulator100ms * 0.1f) != floor(lastTickMs * 0.1f)) {
+    // Even if more than 10 ms has passed, we will only
+    // execute Run10msTasks() once.
+     Run10msTasks();
+  }
+
+  if (mAccumulator100ms >= 100.0f) {
+    // Even if more than 100 ms has passed, we will only
+    // execute Run100msTasks() once.
+    Run100msTasks();
+    mAccumulator100ms = fmod(mAccumulator100ms, 100.0f);
+  }
+
+  uint32_t optimalTaskInterval = GetOptimalTaskInterval();
+  if (mTaskTimer && optimalTaskInterval != mTaskInterval) {
+    mTaskTimer->SetDelay(optimalTaskInterval);
+    mTaskInterval = optimalTaskInterval;
+  }
+}
+
+uint32_t
+VRManager::GetOptimalTaskInterval()
+{
+  /**
+   * When either VR content is detected or VR hardware
+   * has already been activated, we schedule tasks more
+   * frequently.
+   */
+  bool wantGranularTasks = mVRDisplaysRequested ||
+                           mVRControllersRequested ||
+                           mVRDisplays.Count() ||
+                           mVRControllers.Count();
+  if (wantGranularTasks) {
+    return kVRActiveTaskInterval;
+  }
+
+  return kVRIdleTaskInterval;
+}
+
+/**
+ * Run1msTasks() is guaranteed not to be
+ * called more than once within 1ms.
+ * When VR is not active, this will be
+ * called once per VSync if it wasn't
+ * called within the last 1ms.
+ */
+void
+VRManager::Run1msTasks(double aDeltaTime)
+{
+  MOZ_ASSERT(VRListenerThreadHolder::IsInVRListenerThread());
+
+  for (const auto& manager : mManagers) {
+    manager->Run1msTasks(aDeltaTime);
+  }
+
+  for (auto iter = mVRDisplays.Iter(); !iter.Done(); iter.Next()) {
+    gfx::VRDisplayHost* display = iter.UserData();
+    display->Run1msTasks(aDeltaTime);
+  }
+}
+
+/**
+ * Run10msTasks() is guaranteed not to be
+ * called more than once within 10ms.
+ * When VR is not active, this will be
+ * called once per VSync if it wasn't
+ * called within the last 10ms.
+ */
+void
+VRManager::Run10msTasks()
+{
+  MOZ_ASSERT(VRListenerThreadHolder::IsInVRListenerThread());
+
+  UpdateRequestedDevices();
+
+  for (const auto& manager : mManagers) {
+    manager->Run10msTasks();
+  }
+
+  for (auto iter = mVRDisplays.Iter(); !iter.Done(); iter.Next()) {
+    gfx::VRDisplayHost* display = iter.UserData();
+    display->Run10msTasks();
+  }
+}
+
+/**
+ * Run100msTasks() is guaranteed not to be
+ * called more than once within 100ms.
+ * When VR is not active, this will be
+ * called once per VSync if it wasn't
+ * called within the last 100ms.
+ */
+void
+VRManager::Run100msTasks()
+{
+  MOZ_ASSERT(VRListenerThreadHolder::IsInVRListenerThread());
 
   // We must continually refresh the VR display enumeration to check
   // for events that we must fire such as Window.onvrdisplayconnect
   // Note that enumeration itself may activate display hardware, such
   // as Oculus, so we only do this when we know we are displaying content
   // that is looking for VR displays.
   RefreshVRDisplays();
 
   // Update state and enumeration of VR controllers
   RefreshVRControllers();
 
   CheckForInactiveTimeout();
+
+  for (const auto& manager : mManagers) {
+    manager->Run100msTasks();
+  }
+
+  for (auto iter = mVRDisplays.Iter(); !iter.Done(); iter.Next()) {
+    gfx::VRDisplayHost* display = iter.UserData();
+    display->Run100msTasks();
+  }
 }
 
 void
 VRManager::CheckForInactiveTimeout()
 {
   // Shut down the VR devices when not in use
   if (mVRDisplaysRequested || mVRControllersRequested) {
     // We are using a VR device, keep it alive
@@ -306,17 +504,17 @@ VRManager::NotifyVRVsync(const uint32_t&
     }
   }
 
   RefPtr<VRDisplayHost> display = GetDisplay(aDisplayID);
   if (display) {
     display->StartFrame();
   }
 
-  RefreshVRDisplays();
+  DispatchVRDisplayInfoUpdate();
 }
 
 void
 VRManager::EnumerateVRDisplays()
 {
   /**
    * Throttle the rate of enumeration to the interval set in
    * VRDisplayEnumerateInterval

--- a/gfx/vr/VRManager.h
+++ b/gfx/vr/VRManager.h
@@ -9,16 +9,17 @@
 
 #include "nsRefPtrHashtable.h"
 #include "nsTArray.h"
 #include "nsTHashtable.h"
 #include "nsDataHashtable.h"
 #include "mozilla/TimeStamp.h"
 #include "gfxVR.h"
 
+class nsITimer;
 namespace mozilla {
 namespace layers {
 class TextureHost;
 }
 namespace gfx {
 
 class VRLayerParent;
 class VRManagerParent;
@@ -57,26 +58,35 @@ public:
 
   void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
                      double aIntensity, double aDuration, const VRManagerPromise& aPromise);
   void StopVibrateHaptic(uint32_t aControllerIdx);
   void NotifyVibrateHapticCompleted(const VRManagerPromise& aPromise);
   void DispatchSubmitFrameResult(uint32_t aDisplayID, const VRSubmitFrameResultInfo& aResult);
   void StartVRNavigation(const uint32_t& aDisplayID);
   void StopVRNavigation(const uint32_t& aDisplayID, const TimeDuration& aTimeout);
+  static void StopVRListenerThreadTasks();
 
 protected:
   VRManager();
   ~VRManager();
 
 private:
 
   void Init();
   void Destroy();
   void Shutdown();
+  void StartTasks();
+  void StopTasks();
+  static void TaskTimerCallback(nsITimer* aTimer, void* aClosure);
+  void RunTasks();
+  void Run1msTasks(double aDeltaTime);
+  void Run10msTasks();
+  void Run100msTasks();
+  uint32_t GetOptimalTaskInterval();
 
   void DispatchVRDisplayInfoUpdate();
   void UpdateRequestedDevices();
   void EnumerateVRDisplays();
   void CheckForInactiveTimeout();
 
   typedef nsTHashtable<nsRefPtrHashKey<VRManagerParent>> VRManagerParentSet;
   VRManagerParentSet mVRManagerParents;
@@ -90,22 +100,26 @@ private:
   typedef nsRefPtrHashtable<nsUint32HashKey, gfx::VRControllerHost> VRControllerHostHashMap;
   VRControllerHostHashMap mVRControllers;
 
   Atomic<bool> mInitialized;
 
   TimeStamp mLastControllerEnumerationTime;
   TimeStamp mLastDisplayEnumerationTime;
   TimeStamp mLastActiveTime;
+  TimeStamp mLastTickTime;
+  double mAccumulator100ms;
   RefPtr<VRSystemManagerPuppet> mPuppetManager;
   RefPtr<VRSystemManagerExternal> mExternalManager;
 #if defined(XP_WIN) || defined(XP_MACOSX) || (defined(XP_LINUX) && !defined(MOZ_WIDGET_ANDROID))
   RefPtr<VRService> mVRService;
 #endif
   bool mVRDisplaysRequested;
   bool mVRControllersRequested;
   bool mVRServiceStarted;
+  uint32_t mTaskInterval;
+  RefPtr<nsITimer> mTaskTimer;
 };
 
 } // namespace gfx
 } // namespace mozilla
 
 #endif // GFX_VR_MANAGER_H

--- a/gfx/vr/VRThread.cpp
+++ b/gfx/vr/VRThread.cpp
@@ -1,23 +1,24 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 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/. */
 
 #include "VRThread.h"
 #include "nsThreadUtils.h"
+#include "VRManager.h"
 
 namespace mozilla {
 
 namespace gfx {
 
 static StaticRefPtr<VRListenerThreadHolder> sVRListenerThreadHolder;
-static bool sFinishedVRListenerShutDown = false;
+static bool sFinishedVRListenerShutDown = true;
 static const uint32_t kDefaultThreadLifeTime = 60; // in 60 seconds.
 static const uint32_t kDelayPostTaskTime = 20000; // in 20000 ms.
 
 VRListenerThreadHolder* GetVRListenerThreadHolder()
 {
   return sVRListenerThreadHolder;
 }
 
@@ -88,26 +89,26 @@ VRListenerThreadHolder::CreateThread()
   return vrThread;
 }
 
 void
 VRListenerThreadHolder::Start()
 {
   MOZ_ASSERT(NS_IsMainThread(), "Should be on the main thread!");
   MOZ_ASSERT(!sVRListenerThreadHolder, "The VR listener thread has already been started!");
-
+  sFinishedVRListenerShutDown = false;
   sVRListenerThreadHolder = new VRListenerThreadHolder();
 }
 
 void
 VRListenerThreadHolder::Shutdown()
 {
   MOZ_ASSERT(NS_IsMainThread(), "Should be on the main thread!");
   MOZ_ASSERT(sVRListenerThreadHolder, "The VR listener thread has already been shut down!");
-
+  VRManager::StopVRListenerThreadTasks();
   sVRListenerThreadHolder = nullptr;
 
   SpinEventLoopUntil([&]() { return sFinishedVRListenerShutDown; });
 }
 
 /* static */ bool
 VRListenerThreadHolder::IsInVRListenerThread()
 {