--- a/.taskcluster.yml
+++ b/.taskcluster.yml
@@ -50,23 +50,16 @@ tasks:
             The task that creates all of the other tasks in the task graph
 
       workerType: "gecko-decision"
       provisionerId: "aws-provisioner-v1"
 
       tags:
         createdForUser: {{owner}}
 
-      scopes:
-        # Bug 1269443: cache scopes, etc. must be listed explicitly
-        - "docker-worker:cache:level-{{level}}-*"
-        - "docker-worker:cache:tooltool-cache"
-        # mozilla-taskcluster will append the appropriate assume:repo:<repo>
-        # scope here.
-
       routes:
         - "index.gecko.v2.{{project}}.latest.firefox.decision"
         - "tc-treeherder.v2.{{project}}.{{revision}}.{{pushlog_id}}"
         - "tc-treeherder-stage.v2.{{project}}.{{revision}}.{{pushlog_id}}"
 
       payload:
         env:
           # checkout-gecko uses these to check out the source; the inputs

--- a/CLOBBER
+++ b/CLOBBER
@@ -17,9 +17,9 @@
 #
 # Modifying this file will now automatically clobber the buildbot machines \o/
 #
 
 # Are you updating CLOBBER because you think it's needed for your WebIDL
 # changes to stick? As of bug 928195, this shouldn't be necessary! Please
 # don't change CLOBBER for WebIDL changes any more.
 
-Bug 1322938 needs a clobber for test_lowDiskSpace.html on Android
+Bug 1250356 Setting CLOBBER out caution landing a huge patchset with gyp changes

--- a/browser/base/content/sanitize.js
+++ b/browser/base/content/sanitize.js
@@ -152,19 +152,17 @@ Sanitizer.prototype = {
       seenError = true;
       console.error("Error sanitizing " + name, ex);
     };
 
     // Array of objects in form { name, promise }.
     // `name` is the item's name and `promise` may be a promise, if the
     // sanitization is asynchronous, or the function return value, otherwise.
     let handles = [];
-    for (let itemName of itemsToClear) {
-      // Workaround for bug 449811.
-      let name = itemName;
+    for (let name of itemsToClear) {
       let item = this.items[name];
       try {
         // Catch errors here, so later we can just loop through these.
         handles.push({ name,
                        promise: item.clear(range)
                                     .then(() => progress[name] = "cleared",
                                           ex => annotateError(name, ex))
                      });

--- a/browser/components/migration/MigrationUtils.jsm
+++ b/browser/components/migration/MigrationUtils.jsm
@@ -289,31 +289,27 @@ this.MigratorPrototype = {
       let notify = function(aMsg, aItemType) {
         Services.obs.notifyObservers(null, aMsg, aItemType);
       };
 
       for (let resourceType of Object.keys(MigrationUtils._importQuantities)) {
         MigrationUtils._importQuantities[resourceType] = 0;
       }
       notify("Migration:Started");
-      for (let [key, value] of resourcesGroupedByItems) {
-        // Workaround bug 449811.
-        let migrationType = key, itemResources = value;
+      for (let [migrationType, itemResources] of resourcesGroupedByItems) {
 
         notify("Migration:ItemBeforeMigrate", migrationType);
 
         let itemSuccess = false;
         for (let res of itemResources) {
-          // Workaround bug 449811.
-          let resource = res;
-          maybeStartTelemetryStopwatch(migrationType, resource);
+          maybeStartTelemetryStopwatch(migrationType, res);
           let completeDeferred = PromiseUtils.defer();
           let resourceDone = function(aSuccess) {
-            maybeStopTelemetryStopwatch(migrationType, resource);
-            itemResources.delete(resource);
+            maybeStopTelemetryStopwatch(migrationType, res);
+            itemResources.delete(res);
             itemSuccess |= aSuccess;
             if (itemResources.size == 0) {
               notify(itemSuccess ?
                      "Migration:ItemAfterMigrate" : "Migration:ItemError",
                      migrationType);
               resourcesGroupedByItems.delete(migrationType);
               if (resourcesGroupedByItems.size == 0) {
                 collectQuantityTelemetry();
@@ -321,17 +317,17 @@ this.MigratorPrototype = {
               }
             }
             completeDeferred.resolve();
           };
 
           // If migrate throws, an error occurred, and the callback
           // (itemMayBeDone) might haven't been called.
           try {
-            resource.migrate(resourceDone);
+            res.migrate(resourceDone);
           }
           catch (ex) {
             Cu.reportError(ex);
             resourceDone(false);
           }
 
           // Certain resources must be ran sequentially or they could fail,
           // for example bookmarks and history (See bug 1272652).

--- a/browser/components/originattributes/test/browser/browser.ini
+++ b/browser/components/originattributes/test/browser/browser.ini
@@ -64,8 +64,9 @@ support-files =
 [browser_firstPartyIsolation.js]
 [browser_localStorageIsolation.js]
 [browser_blobURLIsolation.js]
 [browser_imageCacheIsolation.js]
 [browser_sharedworker.js]
 [browser_httpauth.js]
 [browser_clientAuth.js]
 [browser_cacheAPI.js]
+[browser_permissions.js]

new file mode 100644
--- /dev/null
+++ b/browser/components/originattributes/test/browser/browser_permissions.js
@@ -0,0 +1,44 @@
+/**
+ * Bug 1282655 - Test if site permissions are universal across origin attributes.
+ *
+ * This test is testing the cookie "permission" for a specific URI.
+ */
+
+const TEST_PAGE = "http://example.net";
+const uri = Services.io.newURI(TEST_PAGE, null, null);
+
+function disableCookies() {
+  Services.cookies.removeAll();
+  Services.perms.add(uri, "cookie", Services.perms.DENY_ACTION);
+}
+
+function ensureCookieNotSet(aBrowser) {
+  ContentTask.spawn(aBrowser, null, function*() {
+    content.document.cookie = "key=value";
+    is(content.document.cookie, "", "Setting/reading cookies should be disabled"
+      + " for this domain for all origin attribute combinations.");
+  });
+}
+
+IsolationTestTools.runTests(TEST_PAGE, ensureCookieNotSet, () => true,
+                            disableCookies);
+
+function enableCookies() {
+  Services.cookies.removeAll();
+  Services.perms.add(uri, "cookie", Services.perms.ALLOW_ACTION);
+}
+
+function ensureCookieSet(aBrowser) {
+  ContentTask.spawn(aBrowser, null, function() {
+    content.document.cookie = "key=value";
+    is(content.document.cookie, "key=value", "Setting/reading cookies should be"
+      + " enabled for this domain for all origin attribute combinations.");
+  });
+}
+
+IsolationTestTools.runTests(TEST_PAGE, ensureCookieSet, () => true,
+                            enableCookies);
+
+registerCleanupFunction(() => {
+    Services.cookies.removeAll();
+});

--- a/build/gyp.mozbuild
+++ b/build/gyp.mozbuild
@@ -34,16 +34,18 @@ gyp_vars.update({
     'build_json': 0,
     'build_icu': 0,
     'build_opus': 0,
     'libyuv_dir': '/media/libyuv',
     'yuv_disable_avx2': 0 if CONFIG['HAVE_X86_AVX2'] else 1,
     # don't use openssl
     'use_openssl': 0,
 
+    'debug': 1 if CONFIG['DEBUG'] else 0,
+
     'use_x11': 1 if CONFIG['MOZ_X11'] else 0,
     'use_glib': 1 if CONFIG['GLIB_LIBS'] else 0,
 
      # turn off mandatory use of NEON and instead use NEON detection
     'arm_neon': 0,
     'arm_neon_optional': 1,
 
     'moz_widget_toolkit_gonk': 0,

--- a/devtools/client/responsive.html/browser/tunnel.js
+++ b/devtools/client/responsive.html/browser/tunnel.js
@@ -483,23 +483,21 @@ MessageManagerTunnel.prototype = {
     if (!this.inner.frameLoader) {
       return null;
     }
     return this.inner.frameLoader.messageManager;
   },
 
   init() {
     for (let method of this.PASS_THROUGH_METHODS) {
-      // Workaround bug 449811 to ensure a fresh binding each time through the loop
-      let _method = method;
-      this[_method] = (...args) => {
+      this[method] = (...args) => {
         if (!this.outerParentMM) {
           return null;
         }
-        return this.outerParentMM[_method](...args);
+        return this.outerParentMM[method](...args);
       };
     }
 
     for (let name of this.INNER_TO_OUTER_MESSAGES) {
       this.innerParentMM.addMessageListener(name, this);
       this.tunneledMessageNames.add(name);
     }
 
@@ -533,23 +531,21 @@ MessageManagerTunnel.prototype = {
     for (let name of this.tunneledMessageNames) {
       this.innerParentMM.removeMessageListener(name, this);
     }
 
     // Some objects may have cached this tunnel as the messageManager for a frame.  To
     // ensure it keeps working after tunnel close, rewrite the overidden methods as pass
     // through methods.
     for (let method of this.OVERRIDDEN_METHODS) {
-      // Workaround bug 449811 to ensure a fresh binding each time through the loop
-      let _method = method;
-      this[_method] = (...args) => {
+      this[method] = (...args) => {
         if (!this.outerParentMM) {
           return null;
         }
-        return this.outerParentMM[_method](...args);
+        return this.outerParentMM[method](...args);
       };
     }
   },
 
   observe(subject, topic, data) {
     if (topic != "message-manager-close") {
       return;
     }

--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -2141,27 +2141,30 @@ Element::DispatchClickEvent(nsPresContex
   NS_PRECONDITION(aSourceEvent, "Must have source event");
   NS_PRECONDITION(aStatus, "Null out param?");
 
   WidgetMouseEvent event(aSourceEvent->IsTrusted(), eMouseClick,
                          aSourceEvent->mWidget, WidgetMouseEvent::eReal);
   event.mRefPoint = aSourceEvent->mRefPoint;
   uint32_t clickCount = 1;
   float pressure = 0;
+  uint32_t pointerId = 0; // Use the default value here.
   uint16_t inputSource = 0;
   WidgetMouseEvent* sourceMouseEvent = aSourceEvent->AsMouseEvent();
   if (sourceMouseEvent) {
     clickCount = sourceMouseEvent->mClickCount;
     pressure = sourceMouseEvent->pressure;
+    pointerId = sourceMouseEvent->pointerId;
     inputSource = sourceMouseEvent->inputSource;
   } else if (aSourceEvent->mClass == eKeyboardEventClass) {
     inputSource = nsIDOMMouseEvent::MOZ_SOURCE_KEYBOARD;
   }
   event.pressure = pressure;
   event.mClickCount = clickCount;
+  event.pointerId = pointerId;
   event.inputSource = inputSource;
   event.mModifiers = aSourceEvent->mModifiers;
   if (aExtraEventFlags) {
     // Be careful not to overwrite existing flags!
     event.mFlags.Union(*aExtraEventFlags);
   }
 
   return DispatchEvent(aPresContext, &event, aTarget, aFullDispatch, aStatus);

--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -8235,16 +8235,17 @@ nsContentUtils::SendMouseEvent(const nsC
                                float aY,
                                int32_t aButton,
                                int32_t aButtons,
                                int32_t aClickCount,
                                int32_t aModifiers,
                                bool aIgnoreRootScrollFrame,
                                float aPressure,
                                unsigned short aInputSourceArg,
+                               uint32_t aIdentifier,
                                bool aToWindow,
                                bool *aPreventDefault,
                                bool aIsDOMEventSynthesized,
                                bool aIsWidgetEventSynthesized)
 {
   nsPoint offset;
   nsCOMPtr<nsIWidget> widget = GetWidget(aPresShell, &offset);
   if (!widget)
@@ -8282,16 +8283,17 @@ nsContentUtils::SendMouseEvent(const nsC
   }
 
   WidgetMouseEvent event(true, msg, widget,
                          aIsWidgetEventSynthesized ?
                            WidgetMouseEvent::eSynthesized :
                            WidgetMouseEvent::eReal,
                          contextMenuKey ? WidgetMouseEvent::eContextMenuKey :
                                           WidgetMouseEvent::eNormal);
+  event.pointerId = aIdentifier;
   event.mModifiers = GetWidgetModifiers(aModifiers);
   event.button = aButton;
   event.buttons = aButtons != nsIDOMWindowUtils::MOUSE_BUTTONS_NOT_SPECIFIED ?
                   aButtons :
                   msg == eMouseUp ? 0 : GetButtonsFlagForButton(aButton);
   event.pressure = aPressure;
   event.inputSource = aInputSourceArg;
   event.mClickCount = aClickCount;

--- a/dom/base/nsContentUtils.h
+++ b/dom/base/nsContentUtils.h
@@ -2581,16 +2581,17 @@ public:
                                  float aY,
                                  int32_t aButton,
                                  int32_t aButtons,
                                  int32_t aClickCount,
                                  int32_t aModifiers,
                                  bool aIgnoreRootScrollFrame,
                                  float aPressure,
                                  unsigned short aInputSourceArg,
+                                 uint32_t aIdentifier,
                                  bool aToWindow,
                                  bool *aPreventDefault,
                                  bool aIsDOMEventSynthesized,
                                  bool aIsWidgetEventSynthesized);
 
   static void FirePageShowEvent(nsIDocShellTreeItem* aItem,
                                 mozilla::dom::EventTarget* aChromeEventHandler,
                                 bool aFireIfShowing);

--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -637,22 +637,26 @@ nsDOMWindowUtils::SendMouseEvent(const n
                                  int32_t aClickCount,
                                  int32_t aModifiers,
                                  bool aIgnoreRootScrollFrame,
                                  float aPressure,
                                  unsigned short aInputSourceArg,
                                  bool aIsDOMEventSynthesized,
                                  bool aIsWidgetEventSynthesized,
                                  int32_t aButtons,
+                                 uint32_t aIdentifier,
                                  uint8_t aOptionalArgCount,
                                  bool *aPreventDefault)
 {
   return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
                               aIgnoreRootScrollFrame, aPressure,
-                              aInputSourceArg, false, aPreventDefault,
+                              aInputSourceArg,
+                              aOptionalArgCount >= 7 ?
+                                aIdentifier : DEFAULT_MOUSE_POINTER_ID,
+                              false, aPreventDefault,
                               aOptionalArgCount >= 4 ?
                                 aIsDOMEventSynthesized : true,
                               aOptionalArgCount >= 5 ?
                                 aIsWidgetEventSynthesized : false,
                               aOptionalArgCount >= 6 ?
                               aButtons : MOUSE_BUTTONS_NOT_SPECIFIED);
 }
 
@@ -664,24 +668,28 @@ nsDOMWindowUtils::SendMouseEventToWindow
                                          int32_t aClickCount,
                                          int32_t aModifiers,
                                          bool aIgnoreRootScrollFrame,
                                          float aPressure,
                                          unsigned short aInputSourceArg,
                                          bool aIsDOMEventSynthesized,
                                          bool aIsWidgetEventSynthesized,
                                          int32_t aButtons,
+                                         uint32_t aIdentifier,
                                          uint8_t aOptionalArgCount)
 {
   PROFILER_LABEL("nsDOMWindowUtils", "SendMouseEventToWindow",
     js::ProfileEntry::Category::EVENTS);
 
   return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
                               aIgnoreRootScrollFrame, aPressure,
-                              aInputSourceArg, true, nullptr,
+                              aInputSourceArg,
+                              aOptionalArgCount >= 7 ?
+                                aIdentifier : DEFAULT_MOUSE_POINTER_ID,
+                              true, nullptr,
                               aOptionalArgCount >= 4 ?
                                 aIsDOMEventSynthesized : true,
                               aOptionalArgCount >= 5 ?
                                 aIsWidgetEventSynthesized : false,
                               aOptionalArgCount >= 6 ?
                               aButtons : MOUSE_BUTTONS_NOT_SPECIFIED);
 }
 
@@ -690,27 +698,28 @@ nsDOMWindowUtils::SendMouseEventCommon(c
                                        float aX,
                                        float aY,
                                        int32_t aButton,
                                        int32_t aClickCount,
                                        int32_t aModifiers,
                                        bool aIgnoreRootScrollFrame,
                                        float aPressure,
                                        unsigned short aInputSourceArg,
+                                       uint32_t aPointerId,
                                        bool aToWindow,
                                        bool *aPreventDefault,
                                        bool aIsDOMEventSynthesized,
                                        bool aIsWidgetEventSynthesized,
                                        int32_t aButtons)
 {
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   return nsContentUtils::SendMouseEvent(presShell, aType, aX, aY, aButton,
       aButtons, aClickCount, aModifiers, aIgnoreRootScrollFrame, aPressure,
-      aInputSourceArg, aToWindow, aPreventDefault, aIsDOMEventSynthesized,
-      aIsWidgetEventSynthesized);
+      aInputSourceArg, aPointerId, aToWindow, aPreventDefault,
+      aIsDOMEventSynthesized, aIsWidgetEventSynthesized);
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::SendPointerEventCommon(const nsAString& aType,
                                          float aX,
                                          float aY,
                                          int32_t aButton,
                                          int32_t aClickCount,

--- a/dom/base/nsDOMWindowUtils.h
+++ b/dom/base/nsDOMWindowUtils.h
@@ -86,16 +86,17 @@ protected:
                                   float aX,
                                   float aY,
                                   int32_t aButton,
                                   int32_t aClickCount,
                                   int32_t aModifiers,
                                   bool aIgnoreRootScrollFrame,
                                   float aPressure,
                                   unsigned short aInputSourceArg,
+                                  uint32_t aIdentifier,
                                   bool aToWindow,
                                   bool *aPreventDefault,
                                   bool aIsDOMEventSynthesized,
                                   bool aIsWidgetEventSynthesized,
                                   int32_t aButtons);
 
   NS_IMETHOD SendPointerEventCommon(const nsAString& aType,
                                     float aX,

--- a/dom/canvas/test/captureStream_common.js
+++ b/dom/canvas/test/captureStream_common.js
@@ -141,18 +141,26 @@ CaptureStreamTestHelper.prototype = {
    * Returns a promise that resolves when the top left pixel of |video| matches
    * on all channels. Use |threshold| for fuzzy matching the color on each
    * channel, in the range [0,255].
    */
   waitForPixelColor: function (video, refColor, threshold, infoString) {
     info("Waiting for video " + video.id + " to match [" +
          refColor.data.join(',') + "] - " + refColor.name +
          " (" + infoString + ")");
+    var paintedFrames = video.mozPaintedFrames-1;
     return this.waitForPixel(video, 0, 0,
-                             px => this.isPixel(px, refColor, threshold))
+                             px => { if (paintedFrames != video.mozPaintedFrames) {
+				       info("Frame: " + video.mozPaintedFrames +
+					    " IsPixel ref=" + refColor.data +
+					    " threshold=" + threshold +
+					    " value=" + px);
+				       paintedFrames = video.mozPaintedFrames;
+				     }
+				     return this.isPixel(px, refColor, threshold); })
       .then(() => ok(true, video.id + " " + infoString));
   },
 
   /*
    * Returns a promise that resolves after |timeout| ms of playback or when the
    * top left pixel of |video| becomes |refColor|. The test is failed if the
    * timeout is not reached.
    */

--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -4492,16 +4492,17 @@ EventStateManager::FireDragEnterOrExit(n
                                        nsWeakFrame& aTargetFrame)
 {
   nsEventStatus status = nsEventStatus_eIgnore;
   WidgetDragEvent event(aDragEvent->IsTrusted(), aMessage, aDragEvent->mWidget);
   event.mRefPoint = aDragEvent->mRefPoint;
   event.mModifiers = aDragEvent->mModifiers;
   event.buttons = aDragEvent->buttons;
   event.relatedTarget = aRelatedTarget;
+  event.pointerId = aDragEvent->pointerId;
   event.inputSource = aDragEvent->inputSource;
 
   mCurrentTargetContent = aTargetContent;
 
   if (aTargetContent != aRelatedTarget) {
     //XXX This event should still go somewhere!!
     if (aTargetContent) {
       EventDispatcher::Dispatch(aTargetContent, aPresContext, &event,
@@ -4643,16 +4644,17 @@ EventStateManager::InitAndDispatchClickE
   event.mRefPoint = aEvent->mRefPoint;
   event.mClickCount = aEvent->mClickCount;
   event.mModifiers = aEvent->mModifiers;
   event.buttons = aEvent->buttons;
   event.mTime = aEvent->mTime;
   event.mTimeStamp = aEvent->mTimeStamp;
   event.mFlags.mNoContentDispatch = aNoContentDispatch;
   event.button = aEvent->button;
+  event.pointerId = aEvent->pointerId;
   event.inputSource = aEvent->inputSource;
 
   return aPresShell->HandleEventWithTarget(&event, aCurrentTarget,
                                            aMouseTarget, aStatus);
 }
 
 nsresult
 EventStateManager::CheckForAndDispatchClick(WidgetMouseEvent* aEvent,

--- a/dom/events/test/pointerevents/mochitest_support_external.js
+++ b/dom/events/test/pointerevents/mochitest_support_external.js
@@ -30,21 +30,23 @@ function turnOnPointerEvents(callback) {
   SpecialPowers.pushPrefEnv({
     "set": [
       ["dom.w3c_pointer_events.enabled", true],
       ["layout.css.touch_action.enabled", true]
     ]
   }, callback);
 }
 
+var utils = SpecialPowers.Ci.nsIDOMWindowUtils;
+
 // Mouse Event Helper Object
 var MouseEventHelper = (function() {
-  var utils = SpecialPowers.Ci.nsIDOMWindowUtils;
-
   return {
+    MOUSE_ID: utils.DEFAULT_MOUSE_POINTER_ID,
+    PEN_ID:   utils.DEFAULT_PEN_POINTER_ID,
     // State
     // TODO: Separate this to support mouse and pen simultaneously.
     BUTTONS_STATE: utils.MOUSE_BUTTONS_NO_BUTTON,
 
     // Button
     BUTTON_NONE:   -1, // Used by test framework only. (replaced before sending)
     BUTTON_LEFT:   utils.MOUSE_BUTTON_LEFT_BUTTON,
     BUTTON_MIDDLE: utils.MOUSE_BUTTON_MIDDLE_BUTTON,
@@ -81,19 +83,24 @@ var MouseEventHelper = (function() {
 
 // Helper function to send MouseEvent with different parameters
 function sendMouseEvent(int_win, elemId, mouseEventType, params) {
   var elem = int_win.document.getElementById(elemId);
   if(!!elem) {
     var rect = elem.getBoundingClientRect();
     var eventObj = {type: mouseEventType};
 
-    if(params && "inputSource" in params)
-      eventObj.inputSource = params.inputSource;
-
+    // Default to mouse.
+    eventObj.inputSource =
+      (params && "inputSource" in params) ? params.inputSource :
+                                            MouseEvent.MOZ_SOURCE_MOUSE;
+    // Compute pointerId
+    eventObj.id =
+      (eventObj.inputSource === MouseEvent.MOZ_SOURCE_MOUSE) ? MouseEventHelper.MOUSE_ID :
+                                                               MouseEventHelper.PEN_ID;
     // Check or generate a |button| value.
     var isButtonEvent = mouseEventType === "mouseup" ||
                         mouseEventType === "mousedown";
 
     // Set |button| to the default value first.
     eventObj.button = isButtonEvent ? MouseEventHelper.BUTTON_LEFT
                                     : MouseEventHelper.BUTTON_NONE;
 
@@ -136,31 +143,36 @@ function sendMouseEvent(int_win, elemId,
   } else {
     is(!!elem, true, "Document should have element with id: " + elemId);
   }
 }
 
 // Touch Event Helper Object
 var TouchEventHelper = {
   // State
-  // TODO: Support multiple point scenarios.
+  TOUCH_ID: utils.DEFAULT_TOUCH_POINTER_ID,
   TOUCH_STATE: false,
 
   // Utils
   checkExitState: function() {
     ok(!this.TOUCH_STATE, "Mismatched touchstart/touchend caught.");
   }
 }
 
 // Helper function to send TouchEvent with different parameters
+// TODO: Support multiple touch points to test more features such as
+// PointerEvent.isPrimary and pinch-zoom.
 function sendTouchEvent(int_win, elemId, touchEventType, params) {
   var elem = int_win.document.getElementById(elemId);
   if(!!elem) {
     var rect = elem.getBoundingClientRect();
-    var eventObj = {type: touchEventType};
+    var eventObj = {
+      type: touchEventType,
+      id: TouchEventHelper.TOUCH_ID
+    };
 
     // Update touch state
     switch(touchEventType) {
       case "touchstart":
         TouchEventHelper.TOUCH_STATE = true; // Set touch flag.
         break;
       case "touchend":
         TouchEventHelper.TOUCH_STATE = false; // Clear touch flag.
@@ -178,40 +190,50 @@ function sendTouchEvent(int_win, elemId,
     is(!!elem, true, "Document should have element with id: " + elemId);
   }
 }
 
 // Helper function to run Point Event test in a new tab.
 function runTestInNewWindow(aFile) {
   var testURL = location.href.substring(0, location.href.lastIndexOf('/') + 1) + aFile;
   var testWindow = window.open(testURL, "_blank");
+  var testDone = false;
 
   // We start testing when receiving load event. Inject the mochitest helper js
   // to the test case after DOM elements are constructed and before the load
   // event is fired.
   testWindow.addEventListener("DOMContentLoaded", function scriptInjector() {
     testWindow.removeEventListener("DOMContentLoaded", scriptInjector);
     const PARENT_ORIGIN = "http://mochi.test:8888/";
     var e = testWindow.document.createElement('script');
     e.type = 'text/javascript';
     e.src = "mochitest_support_internal.js";
     testWindow.document.getElementsByTagName('head')[0].appendChild(e);
   });
 
   window.addEventListener("message", function(aEvent) {
     switch(aEvent.data.type) {
       case "START":
+        // Update constants
+        MouseEventHelper.MOUSE_ID = aEvent.data.message.mouseId;
+        MouseEventHelper.PEN_ID   = aEvent.data.message.penId;
+        TouchEventHelper.TOUCH_ID = aEvent.data.message.touchId;
+
         turnOnPointerEvents(() => {
           executeTest(testWindow);
         });
         return;
       case "RESULT":
-        ok(aEvent.data.result, aEvent.data.message);
+        // Should not perform checking after SimpleTest.finish().
+        if (!testDone) {
+          ok(aEvent.data.result, aEvent.data.message);
+        }
         return;
       case "FIN":
+        testDone = true;
         MouseEventHelper.checkExitState();
         TouchEventHelper.checkExitState();
         testWindow.close();
         SimpleTest.finish();
         return;
     }
   });
 }

--- a/dom/events/test/pointerevents/mochitest_support_internal.js
+++ b/dom/events/test/pointerevents/mochitest_support_internal.js
@@ -1,43 +1,80 @@
 // This file supports translating W3C tests
 // to tests on auto MochiTest system with minimum changes.
 // Author: Maksim Lebedev <alessarik@gmail.com>
 
 const PARENT_ORIGIN = "http://mochi.test:8888/";
 
+// Since web platform tests don't check pointerId, we have to use some heuristic
+// to test them. and thus pointerIds are send to mochitest_support_external.js
+// before we start sending synthesized widget events. Here, we avoid using
+// default values used in Gecko to insure everything works as expected.
+const POINTER_MOUSE_ID = 7;
+const POINTER_PEN_ID   = 8;
+const POINTER_TOUCH_ID = 9; // Extend for multiple touch points if needed.
+
 // Setup environment.
 addListeners(document.getElementById("target0"));
 addListeners(document.getElementById("target1"));
 
 // Setup communication between mochitest_support_external.js.
 // Function allows to initialize prerequisites before testing
 // and adds some callbacks to support mochitest system.
-add_result_callback((aTestObj) => {
+function resultCallback(aTestObj) {
   var message = aTestObj["name"] + " (";
   message += "Get: " + JSON.stringify(aTestObj["status"]) + ", ";
   message += "Expect: " + JSON.stringify(aTestObj["PASS"]) + ")";
   window.opener.postMessage({type: "RESULT",
                              message: message,
                              result: aTestObj["status"] === aTestObj["PASS"]},
                             PARENT_ORIGIN);
-});
+}
 
+add_result_callback(resultCallback);
 add_completion_callback(() => {
   window.opener.postMessage({type: "FIN"}, PARENT_ORIGIN);
 });
 
 window.addEventListener("load", () => {
-  // Start testing when the document is loaded.
-  window.opener.postMessage({type: "START"}, PARENT_ORIGIN);
+  // Start testing.
+  var startMessage = {
+    type: "START",
+    message: {
+      mouseId: POINTER_MOUSE_ID,
+      penId:   POINTER_PEN_ID,
+      touchId: POINTER_TOUCH_ID
+    }
+  }
+  window.opener.postMessage(startMessage, PARENT_ORIGIN);
 });
 
 function addListeners(elem) {
   if(!elem)
     return;
   var All_Events = ["pointerdown","pointerup","pointercancel","pointermove","pointerover","pointerout",
                     "pointerenter","pointerleave","gotpointercapture","lostpointercapture"];
   All_Events.forEach(function(name) {
     elem.addEventListener(name, function(event) {
       console.log('('+event.type+')-('+event.pointerType+')');
+
+      // Perform checks only for trusted events.
+      if (!event.isTrusted) {
+        return;
+      }
+
+      // Compute the desired event.pointerId from event.pointerType.
+      var pointerId = {
+        mouse: POINTER_MOUSE_ID,
+        pen:   POINTER_PEN_ID,
+        touch: POINTER_TOUCH_ID
+      }[event.pointerType];
+
+      // Compare the pointerId.
+      resultCallback({
+        name:   "Mismatched event.pointerId recieved.",
+        status: event.pointerId,
+        PASS:   pointerId
+      });
+
     }, false);
   });
 }

--- a/dom/interfaces/base/nsIDOMWindowUtils.idl
+++ b/dom/interfaces/base/nsIDOMWindowUtils.idl
@@ -317,32 +317,35 @@ interface nsIDOMWindowUtils : nsISupport
    * @param aPressure touch input pressure: 0.0 -> 1.0
    * @param aInputSourceArg input source, see nsIDOMMouseEvent for values,
    *        defaults to mouse input.
    * @param aIsDOMEventSynthesized controls nsIDOMEvent.isSynthesized value
    *                               that helps identifying test related events,
    *                               defaults to true
    * @param aIsWidgetEventSynthesized controls WidgetMouseEvent.mReason value
    *                                  defaults to false (WidgetMouseEvent::eReal)
+   * @param aIdentifier A unique identifier for the pointer causing the event,
+   *                    defaulting to nsIDOMWindowUtils::DEFAULT_MOUSE_POINTER_ID.
    *
    * returns true if the page called prevent default on this event
    */
   [optional_argc]
   boolean sendMouseEvent(in AString aType,
                          in float aX,
                          in float aY,
                          in long aButton,
                          in long aClickCount,
                          in long aModifiers,
                          [optional] in boolean aIgnoreRootScrollFrame,
                          [optional] in float aPressure,
                          [optional] in unsigned short aInputSourceArg,
                          [optional] in boolean aIsDOMEventSynthesized,
                          [optional] in boolean aIsWidgetEventSynthesized,
-                         [optional] in long aButtons);
+                         [optional] in long aButtons,
+                         [optional] in unsigned long aIdentifier);
 
 
   /** Synthesize a pointer event. The event types supported are:
    *    pointerdown, pointerup, pointermove, pointerover, pointerout
    *
    * Events are sent in coordinates offset by aX and aY from the window.
    *
    * Note that additional events may be fired as a result of this call. For
@@ -367,17 +370,18 @@ interface nsIDOMWindowUtils : nsISupport
    * @param aButton button to synthesize
    * @param aClickCount number of clicks that have been performed
    * @param aModifiers modifiers pressed, using constants defined as MODIFIER_*
    * @param aIgnoreRootScrollFrame whether the event should ignore viewport bounds
    *                           during dispatch
    * @param aPressure touch input pressure: 0.0 -> 1.0
    * @param aInputSourceArg input source, see nsIDOMMouseEvent for values,
    *        defaults to mouse input.
-   * @param aPointerId A unique identifier for the pointer causing the event. default is 0
+   * @param aPointerId A unique identifier for the pointer causing the event,
+   *                   defaulting to nsIDOMWindowUtils::DEFAULT_MOUSE_POINTER_ID.
    * @param aWidth The width (magnitude on the X axis), default is 0
    * @param aHeight The height (magnitude on the Y axis), default is 0
    * @param aTilt The plane angle between the Y-Z plane
    *        and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis. default is 0
    * @param aTiltX The plane angle between the X-Z plane
    *        and the plane containing both the transducer (e.g. pen stylus) axis and the X axis. default is 0
    * @param aIsPrimary  Indicates if the pointer represents the primary pointer of this pointer type.
    * @param aIsSynthesized controls nsIDOMEvent.isSynthesized value
@@ -453,17 +457,18 @@ interface nsIDOMWindowUtils : nsISupport
                               in long aButton,
                               in long aClickCount,
                               in long aModifiers,
                               [optional] in boolean aIgnoreRootScrollFrame,
                               [optional] in float aPressure,
                               [optional] in unsigned short aInputSourceArg,
                               [optional] in boolean aIsDOMEventSynthesized,
                               [optional] in boolean aIsWidgetEventSynthesized,
-                              [optional] in long aButtons);
+                              [optional] in long aButtons,
+                              [optional] in unsigned long aIdentifier);
 
   /** The same as sendPointerEvent but ensures that the event
    *  is dispatched to this DOM window or one of its children.
    */
   [optional_argc]
   void sendPointerEventToWindow(in AString aType,
                                 in float aX,
                                 in float aY,
@@ -1974,16 +1979,21 @@ interface nsIDOMWindowUtils : nsISupport
   readonly attribute int32_t gpuProcessPid;
 
   /**
    * Returns true if the given timeout ID is in the list of tracking
    * timeouts.
    */
   boolean isTimeoutTracking(in unsigned long timeoutId);
 
+  // These consts are only for testing purposes.
+  const long DEFAULT_MOUSE_POINTER_ID = 0;
+  const long DEFAULT_PEN_POINTER_ID   = 1;
+  const long DEFAULT_TOUCH_POINTER_ID = 2;
+
   // Match WidgetMouseEventBase::buttonType.
   const long MOUSE_BUTTON_LEFT_BUTTON   = 0;
   const long MOUSE_BUTTON_MIDDLE_BUTTON = 1;
   const long MOUSE_BUTTON_RIGHT_BUTTON  = 2;
 
   // Match WidgetMouseEventBase::buttonsFlag.
   const long MOUSE_BUTTONS_NO_BUTTON = 0x00;
   const long MOUSE_BUTTONS_LEFT_BUTTON = 0x01;

--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -1553,17 +1553,18 @@ TabChild::RecvMouseEvent(const nsString&
                          const float&    aX,
                          const float&    aY,
                          const int32_t&  aButton,
                          const int32_t&  aClickCount,
                          const int32_t&  aModifiers,
                          const bool&     aIgnoreRootScrollFrame)
 {
   APZCCallbackHelper::DispatchMouseEvent(GetPresShell(), aType, CSSPoint(aX, aY),
-      aButton, aClickCount, aModifiers, aIgnoreRootScrollFrame, nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN);
+      aButton, aClickCount, aModifiers, aIgnoreRootScrollFrame,
+      nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN, 0 /* Use the default value here. */);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 TabChild::RecvRealMouseMoveEvent(const WidgetMouseEvent& aEvent,
                                  const ScrollableLayerGuid& aGuid,
                                  const uint64_t& aInputBlockId)
 {

--- a/dom/media/systemservices/CamerasChild.cpp
+++ b/dom/media/systemservices/CamerasChild.cpp
@@ -1,17 +1,16 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set sw=2 ts=8 et ft=cpp : */
 /* 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 "CamerasChild.h"
 
-#include "webrtc/video_engine/include/vie_capture.h"
 #undef FF
 
 #include "mozilla/Assertions.h"
 #include "mozilla/ipc/BackgroundChild.h"
 #include "mozilla/ipc/PBackgroundChild.h"
 #include "mozilla/Logging.h"
 #include "mozilla/SyncRunnable.h"
 #include "mozilla/WeakPtr.h"
@@ -340,17 +339,17 @@ CamerasChild::EnsureInitialized(CaptureE
   LOG(("Capture Devices: %d", dispatcher.ReturnValue()));
   return dispatcher.ReturnValue();
 }
 
 int
 CamerasChild::GetCaptureCapability(CaptureEngine aCapEngine,
                                    const char* unique_idUTF8,
                                    const unsigned int capability_number,
-                                   webrtc::CaptureCapability& capability)
+                                   webrtc::VideoCaptureCapability& capability)
 {
   LOG(("GetCaptureCapability: %s %d", unique_idUTF8, capability_number));
   nsCString unique_id(unique_idUTF8);
   nsCOMPtr<nsIRunnable> runnable =
     media::NewRunnableFrom([this, aCapEngine, unique_id, capability_number]() -> nsresult {
       if (this->SendGetCaptureCapability(aCapEngine, unique_id, capability_number)) {
         return NS_OK;
       }
@@ -359,17 +358,17 @@ CamerasChild::GetCaptureCapability(Captu
   LockAndDispatch<> dispatcher(this, __func__, runnable);
   if (dispatcher.Success()) {
     capability = mReplyCapability;
   }
   return dispatcher.ReturnValue();
 }
 
 mozilla::ipc::IPCResult
-CamerasChild::RecvReplyGetCaptureCapability(const CaptureCapability& ipcCapability)
+CamerasChild::RecvReplyGetCaptureCapability(const VideoCaptureCapability& ipcCapability)
 {
   LOG((__PRETTY_FUNCTION__));
   MonitorAutoLock monitor(mReplyMonitor);
   mReceivedReply = true;
   mReplySuccess = true;
   mReplyCapability.width = ipcCapability.width();
   mReplyCapability.height = ipcCapability.height();
   mReplyCapability.maxFPS = ipcCapability.maxFPS();
@@ -424,33 +423,33 @@ CamerasChild::RecvReplyGetCaptureDevice(
   monitor.Notify();
   return IPC_OK();
 }
 
 int
 CamerasChild::AllocateCaptureDevice(CaptureEngine aCapEngine,
                                     const char* unique_idUTF8,
                                     const unsigned int unique_idUTF8Length,
-                                    int& capture_id,
+                                    int& aStreamId,
                                     const nsACString& aOrigin)
 {
   LOG((__PRETTY_FUNCTION__));
   nsCString unique_id(unique_idUTF8);
   nsCString origin(aOrigin);
   nsCOMPtr<nsIRunnable> runnable =
     media::NewRunnableFrom([this, aCapEngine, unique_id, origin]() -> nsresult {
       if (this->SendAllocateCaptureDevice(aCapEngine, unique_id, origin)) {
         return NS_OK;
       }
       return NS_ERROR_FAILURE;
     });
   LockAndDispatch<> dispatcher(this, __func__, runnable);
   if (dispatcher.Success()) {
     LOG(("Capture Device allocated: %d", mReplyInteger));
-    capture_id = mReplyInteger;
+    aStreamId = mReplyInteger;
   }
   return dispatcher.ReturnValue();
 }
 
 
 mozilla::ipc::IPCResult
 CamerasChild::RecvReplyAllocateCaptureDevice(const int& numdev)
 {
@@ -476,17 +475,17 @@ CamerasChild::ReleaseCaptureDevice(Captu
       return NS_ERROR_FAILURE;
     });
   LockAndDispatch<> dispatcher(this, __func__, runnable);
   return dispatcher.ReturnValue();
 }
 
 void
 CamerasChild::AddCallback(const CaptureEngine aCapEngine, const int capture_id,
-                          webrtc::ExternalRenderer* render)
+                          FrameRelay* render)
 {
   MutexAutoLock lock(mCallbackMutex);
   CapturerElement ce;
   ce.engine = aCapEngine;
   ce.id = capture_id;
   ce.callback = render;
   mCallbacks.AppendElement(ce);
 }
@@ -502,22 +501,22 @@ CamerasChild::RemoveCallback(const Captu
       break;
     }
   }
 }
 
 int
 CamerasChild::StartCapture(CaptureEngine aCapEngine,
                            const int capture_id,
-                           webrtc::CaptureCapability& webrtcCaps,
-                           webrtc::ExternalRenderer* cb)
+                           webrtc::VideoCaptureCapability& webrtcCaps,
+                           FrameRelay* cb)
 {
   LOG((__PRETTY_FUNCTION__));
   AddCallback(aCapEngine, capture_id, cb);
-  CaptureCapability capCap(webrtcCaps.width,
+  VideoCaptureCapability capCap(webrtcCaps.width,
                            webrtcCaps.height,
                            webrtcCaps.maxFPS,
                            webrtcCaps.expectedCaptureDelay,
                            webrtcCaps.rawType,
                            webrtcCaps.codecType,
                            webrtcCaps.interlaced);
   nsCOMPtr<nsIRunnable> runnable =
     media::NewRunnableFrom([this, aCapEngine, capture_id, capCap]() -> nsresult {
@@ -641,28 +640,22 @@ CamerasChild::ShutdownChild()
   }
   CamerasSingleton::FakeDeviceChangeEventThread() = nullptr;
 }
 
 mozilla::ipc::IPCResult
 CamerasChild::RecvDeliverFrame(const CaptureEngine& capEngine,
                                const int& capId,
                                mozilla::ipc::Shmem&& shmem,
-                               const size_t& size,
-                               const uint32_t& time_stamp,
-                               const int64_t& ntp_time,
-                               const int64_t& render_time)
+                               const VideoFrameProperties & prop)
 {
   MutexAutoLock lock(mCallbackMutex);
   if (Callback(capEngine, capId)) {
     unsigned char* image = shmem.get<unsigned char>();
-    Callback(capEngine, capId)->DeliverFrame(image, size,
-                                             time_stamp,
-                                             ntp_time, render_time,
-                                             nullptr);
+    Callback(capEngine, capId)->DeliverFrame(image, prop);
   } else {
     LOG(("DeliverFrame called with dead callback"));
   }
   SendReleaseFrame(shmem);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
@@ -697,17 +690,17 @@ CamerasChild::SetFakeDeviceChangeEvents(
 mozilla::ipc::IPCResult
 CamerasChild::RecvFrameSizeChange(const CaptureEngine& capEngine,
                                   const int& capId,
                                   const int& w, const int& h)
 {
   LOG((__PRETTY_FUNCTION__));
   MutexAutoLock lock(mCallbackMutex);
   if (Callback(capEngine, capId)) {
-    Callback(capEngine, capId)->FrameSizeChange(w, h, 0);
+    Callback(capEngine, capId)->FrameSizeChange(w, h);
   } else {
     LOG(("Frame size change with dead callback"));
   }
   return IPC_OK();
 }
 
 void
 CamerasChild::ActorDestroy(ActorDestroyReason aWhy)
@@ -741,17 +734,17 @@ CamerasChild::~CamerasChild()
     // get destructed immediately, and should not try to reach
     // the parent.
     ShutdownChild();
   }
 
   MOZ_COUNT_DTOR(CamerasChild);
 }
 
-webrtc::ExternalRenderer* CamerasChild::Callback(CaptureEngine aCapEngine,
+FrameRelay* CamerasChild::Callback(CaptureEngine aCapEngine,
                                                  int capture_id)
 {
   for (unsigned int i = 0; i < mCallbacks.Length(); i++) {
     CapturerElement ce = mCallbacks[i];
     if (ce.engine == aCapEngine && ce.id == capture_id) {
       return ce.callback;
     }
   }