Merge mozilla-central to autoland
authorarthur.iakab <aiakab@mozilla.com>
Tue, 25 Dec 2018 11:55:20 +0200
changeset 509013 9f75719c6dcd06f391b61bdad888015512627bef
parent 509012 79ce2f9f2dd4ce0e68205c171ebd04a420130092 (current diff)
parent 509011 47d3977ee67ef6e2dbdcc5ce83a159c1c8e886f5 (diff)
child 509014 21d8c62ee69ef56ca8c7bed3ae17c4092bbb4e65
push id10547
push userffxbld-merge
push dateMon, 21 Jan 2019 13:03:58 +0000
treeherdermozilla-beta@24ec1916bffe [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone66.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-central to autoland
dom/smil/nsSMILFloatType.cpp
dom/smil/nsSMILFloatType.h
--- a/browser/components/extensions/test/browser/browser-common.ini
+++ b/browser/components/extensions/test/browser/browser-common.ini
@@ -55,17 +55,17 @@ skip-if = os == 'linux'
 [browser_ext_browserAction_pageAction_icon.js]
 [browser_ext_browserAction_pageAction_icon_permissions.js]
 [browser_ext_browserAction_popup.js]
 skip-if = (debug && os == 'linux' && bits == 32) || (os == 'win' && !debug) # Bug 1313372, win: Bug 1285500
 [browser_ext_browserAction_popup_port.js]
 [browser_ext_browserAction_popup_preload.js]
 skip-if = (os == 'win' && !debug) || (verify && debug && (os == 'mac')) # bug 1352668
 [browser_ext_browserAction_popup_resize.js]
-skip-if = (os == 'mac' && debug) # Bug 1482004, also fails in test-verify
+skip-if = (os == 'mac' || os == 'win' || os == 'linux') || (verify && debug) #Bug 1482004,1483701
 [browser_ext_browserAction_simple.js]
 [browser_ext_browserAction_telemetry.js]
 [browser_ext_browserAction_theme_icons.js]
 [browser_ext_browsingData_formData.js]
 [browser_ext_browsingData_history.js]
 [browser_ext_browsingData_indexedDB.js]
 [browser_ext_browsingData_localStorage.js]
 [browser_ext_browsingData_pluginData.js]
--- a/build/moz.configure/toolchain.configure
+++ b/build/moz.configure/toolchain.configure
@@ -752,66 +752,44 @@ def vc_compiler_path(host, target, vs_ma
         # Choose the newest version.
         data = all_versions[-1][1]
     paths = data.get(vc_target)
     if not paths:
         return
     return paths
 
 
-@dependable
-@imports(_from='os', _import='environ')
-def original_path():
-    return environ['PATH']
-
-
-@depends(vc_compiler_path, original_path)
+@depends(vc_compiler_path)
 @imports('os')
 @imports(_from='os', _import='environ')
-def toolchain_search_path(vc_compiler_path, original_path):
-    result = [original_path]
+def toolchain_search_path(vc_compiler_path):
+    result = [environ.get('PATH')]
 
     if vc_compiler_path:
-        # The second item, if there is one, is necessary to have in $PATH for
-        # Windows to load the required DLLs from there.
-        if len(vc_compiler_path) > 1:
-            environ['PATH'] = os.pathsep.join(result + vc_compiler_path[1:])
-
-        # The first item is where the programs are going to be
-        result.append(vc_compiler_path[0])
+        result.extend(vc_compiler_path)
 
     # 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')))
     bootstrap_clang_path = os.path.join(mozbuild_state_dir, 'clang', 'bin')
     result.append(bootstrap_clang_path)
 
     bootstrap_cbindgen_path = os.path.join(mozbuild_state_dir, 'cbindgen')
     result.append(bootstrap_cbindgen_path)
 
+    if vc_compiler_path:
+        # We're going to alter PATH for good in windows.configure, but we also
+        # need to do it for the valid_compiler() check below. This is only needed
+        # on Windows, where MSVC needs PATH set to find dlls.
+        environ['PATH'] = os.pathsep.join(result)
+
     return result
 
 
-# If we modified the PATH environment variable for Windows DLLs, set the PATH
-# variable for the build.
-@depends(toolchain_search_path, original_path)
-@imports(_from='os', _import='environ')
-def altered_path(toolchain_search_path, original_path):
-    # Touch the dependency for the linter. We don't actually need the value,
-    # only its side effects.
-    toolchain_search_path
-
-    if environ['PATH'] != original_path:
-        return environ['PATH']
-
-
-set_config('PATH', altered_path)
-
-
 @template
 def default_c_compilers(host_or_target, other_c_compiler=None):
     '''Template defining the set of default C compilers for the host and
     target platforms.
     `host_or_target` is either `host` or `target` (the @depends functions
     from init.configure.
     `other_c_compiler` is the `target` C compiler when `host_or_target` is `host`.
     '''
@@ -1016,16 +994,36 @@ def compiler(language, host_or_target, c
             wrapper.extend(provided_wrapper)
             flags = provided_compiler.flags
         else:
             flags = []
 
         if not flags and macos_sdk and host_or_target.os == 'OSX':
             flags = ['-isysroot', macos_sdk]
 
+        # Ideally, we'd always use the absolute path, but unfortunately, on
+        # Windows, the compiler is very often in a directory containing spaces.
+        # Unfortunately, due to the way autoconf does its compiler tests with
+        # eval, that doesn't work out. So in that case, check that the
+        # compiler can still be found in $PATH, and use the file name instead
+        # of the full path.
+        if quote(compiler) != compiler:
+            full_path = os.path.abspath(compiler)
+            compiler = os.path.basename(compiler)
+            found_compiler = find_program(compiler)
+            if not found_compiler:
+                die('%s is not in your $PATH'
+                    % quote(os.path.dirname(full_path)))
+            if os.path.normcase(find_program(compiler)) != os.path.normcase(
+                    full_path):
+                die('Found `%s` before `%s` in your $PATH. '
+                    'Please reorder your $PATH.',
+                    quote(os.path.dirname(found_compiler)),
+                    quote(os.path.dirname(full_path)))
+
         info = check_compiler(wrapper + [compiler] + flags, language,
                               host_or_target)
 
         # Check that the additional flags we got are enough to not require any
         # more flags. If we get an exception, just ignore it; it's liable to be
         # invalid command-line flags, which means the compiler we're checking
         # doesn't support those command-line flags and will fail one or more of
         # the checks below.
@@ -1462,18 +1460,17 @@ def pgo_flags(compiler, build_env, targe
 
 
 set_config('PROFILE_GEN_CFLAGS', pgo_flags.gen_cflags)
 set_config('PROFILE_GEN_LDFLAGS', pgo_flags.gen_ldflags)
 set_config('PROFILE_USE_CFLAGS', pgo_flags.use_cflags)
 set_config('PROFILE_USE_LDFLAGS', pgo_flags.use_ldflags)
 
 llvm_profdata = check_prog('LLVM_PROFDATA', ['llvm-profdata'],
-                           allow_missing=True,
-                           paths=toolchain_search_path)
+                           allow_missing=True)
 
 add_old_configure_assignment('LLVM_PROFDATA', llvm_profdata)
 
 
 @depends(c_compiler)
 def preprocess_option(compiler):
     # The uses of PREPROCESS_OPTION depend on the spacing for -o/-Fi.
     if compiler.type in ('gcc', 'clang'):
@@ -1955,18 +1952,17 @@ def as_info(target, c_compiler):
 # One would expect the assembler to be specified merely as a program.  But in
 # cases where the assembler is passed down into js/, it can be specified in
 # the same way as CC: a program + a list of argument flags.  We might as well
 # permit the same behavior in general, even though it seems somewhat unusual.
 # So we have to do the same sort of dance as we did above with
 # `provided_compiler`.
 provided_assembler = provided_program('AS')
 assembler = check_prog('_AS', input=provided_assembler.program,
-                       what='the assembler', progs=as_info.names,
-                       paths=toolchain_search_path)
+                       what='the assembler', progs=as_info.names)
 
 @depends(as_info, assembler, provided_assembler, c_compiler)
 def as_with_flags(as_info, assembler, provided_assembler, c_compiler):
     if provided_assembler:
         return provided_assembler.wrapper + \
             [provided_assembler.program] + \
             provided_assembler.flags
 
--- a/build/moz.configure/windows.configure
+++ b/build/moz.configure/windows.configure
@@ -251,33 +251,37 @@ def valid_ucrt_sdk_dir(windows_sdk_dir, 
     return namespace(
         path=sdk.path,
         include=sdk.include,
         lib=sdk.lib,
         version=version,
     )
 
 
-@depends(c_compiler, toolchain_search_path)
+@depends(c_compiler)
 @imports('os')
-def vc_path(c_compiler, toolchain_search_path):
+def vc_path(c_compiler):
     vc_path_env = os.environ.get('VC_PATH')
     if vc_path_env:
         return os.path.normpath(vc_path_env)
 
     if c_compiler.type not in ('msvc', 'clang-cl'):
         return
 
+    # Normally, we'd start from c_compiler.compiler, but for now, it's not the
+    # ideal full path to the compiler. At least, we're guaranteed find_program
+    # will get us the one we found in toolchain.configure.
     vc_program = c_compiler.compiler
 
     # In clang-cl builds, we use the headers and libraries from an MSVC installation.
     if c_compiler.type == 'clang-cl':
-        vc_program = find_program('cl.exe', paths=toolchain_search_path)
+        vc_program = 'cl.exe'
 
-    result = os.path.dirname(vc_program)
+    cl = find_program(vc_program)
+    result = os.path.dirname(cl)
     while True:
         next, p = os.path.split(result)
         if next == result:
             die('Cannot determine the Visual C++ directory the compiler (%s) '
                 'is in' % cl)
         result = next
         if p.lower() == 'bin':
             break
@@ -459,16 +463,30 @@ link = check_prog('LINKER', ('lld-link.e
                   paths=toolchain_search_path)
 
 host_link = check_prog('HOST_LINKER', ('lld-link.exe', 'link.exe'),
                        paths=toolchain_search_path)
 
 add_old_configure_assignment('LINKER', link)
 
 
+# Normally, we'd just have CC, etc. set to absolute paths, but the build system
+# doesn't currently handle properly the case where the paths contain spaces.
+# Additionally, there's the issue described in toolchain.configure, in
+# valid_compiler().
+@depends(sdk_bin_path)
+@imports('os')
+def alter_path(sdk_bin_path):
+    path = os.pathsep.join(sdk_bin_path)
+    os.environ['PATH'] = path
+    return path
+
+
+set_config('PATH', alter_path)
+
 check_prog('MAKECAB', ('makecab.exe',))
 
 
 @depends(c_compiler, using_sccache)
 def need_showincludes_prefix(info, using_sccache):
     # sccache does its own -showIncludes prefix checking.
     # clang-cl uses a gcc-style dependency scheme, see toolchain.configure.
     if info.type == 'msvc' and not using_sccache:
--- a/build/win64-aarch64/mozconfig.vs2017
+++ b/build/win64-aarch64/mozconfig.vs2017
@@ -40,15 +40,8 @@ if [ -d "${VSPATH}" ]; then
     libs="${libs} -LIBPATH:${VSWINPATH}/SDK/Lib/${win_sdk_version}/ucrt/x64"
     export HOST_LDFLAGS="${libs}"
 
     export WIN64_LINK="${VSPATH}/VC/bin/Hostx64/x64/link.exe"
     export WIN64_LIB="${VSPATH}/VC/lib/x64:${VSPATH}/VC/atlmfc/lib/x64:${VSPATH}/SDK/Lib/${win_sdk_version}/ucrt/x64:${VSPATH}/SDK/Lib/${win_sdk_version}/um/x64:${VSPATH}/DIA SDK/lib/amd64"
 fi
 
 . $topsrcdir/build/mozconfig.vs-common
-
-mk_export_correct_style WINDOWSSDKDIR
-mk_export_correct_style WIN32_REDIST_DIR
-mk_export_correct_style WIN_DIA_SDK_BIN_DIR
-mk_export_correct_style PATH
-mk_export_correct_style INCLUDE
-mk_export_correct_style LIB
--- a/devtools/client/debugger/new/test/mochitest/browser.ini
+++ b/devtools/client/debugger/new/test/mochitest/browser.ini
@@ -587,16 +587,17 @@ support-files =
   examples/doc-react.html
   examples/wasm-sourcemaps/fib.c
   examples/wasm-sourcemaps/fib.wasm
   examples/wasm-sourcemaps/fib.wasm.map
   examples/wasm-sourcemaps/utils.js
   examples/fetch.js
   examples/doc-xhr.html
   examples/doc-xhr-run-to-completion.html
+  examples/doc-scroll-run-to-completion.html
   examples/sum/sum.js
   examples/sum/sum.min.js
   examples/sum/sum.min.js.map
   examples/big-sourcemap_files/bundle.js
   examples/big-sourcemap_files/bundle.js.map
   examples/reload/code_reload_1.js
   examples/reload/code_reload_2.js
   examples/reload/doc-reload.html
@@ -645,28 +646,31 @@ support-files =
   examples/simple2.js
   examples/simple3.js
   examples/frames.js
   examples/pause-points.js
   examples/script-mutate.js
   examples/script-switching-02.js
   examples/script-switching-01.js
   examples/times2.js
+  examples/doc-windowless-workers.html
+  examples/simple-worker.js
   examples/doc_rr_basic.html
   examples/doc_rr_continuous.html
   examples/doc_rr_logs.html
   examples/doc_rr_recovery.html
   examples/doc_rr_error.html
 
 [browser_dbg-asm.js]
 [browser_dbg-async-stepping.js]
 [browser_dbg-sourcemapped-breakpoint-console.js]
 skip-if = (os == "win" && ccov) # Bug 1453549
 [browser_dbg-xhr-breakpoints.js]
 [browser_dbg-xhr-run-to-completion.js]
+[browser_dbg-scroll-run-to-completion.js]
 [browser_dbg-sourcemapped-scopes.js]
 skip-if = ccov || (verify && debug && (os == 'linux')) # Bug 1441545
 [browser_dbg-sourcemapped-stepping.js]
 skip-if = (os == 'win' && os_version == '10.0' && ccov) # Bug 1480680
 [browser_dbg-sourcemapped-preview.js]
 skip-if = os == "win" # Bug 1448523, Bug 1448450
 [browser_dbg-breaking.js]
 [browser_dbg-breaking-from-console.js]
@@ -757,16 +761,17 @@ skip-if = debug || (verify && (os == 'wi
 skip-if = os == "win"
 [browser_dbg-tabs-pretty-print.js]
 [browser_dbg-tabs-without-urls.js]
 [browser_dbg-toggling-tools.js]
 [browser_dbg-react-app.js]
 skip-if = os == "win"
 [browser_dbg-wasm-sourcemaps.js]
 skip-if = true
+[browser_dbg-windowless-workers.js]
 [browser_dbg_rr_breakpoints-01.js]
 skip-if = os != "mac" || debug || !nightly_build
 [browser_dbg_rr_breakpoints-02.js]
 skip-if = os != "mac" || debug || !nightly_build
 [browser_dbg_rr_breakpoints-03.js]
 skip-if = os != "mac" || debug || !nightly_build
 [browser_dbg_rr_breakpoints-04.js]
 skip-if = os != "mac" || debug || !nightly_build
new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-scroll-run-to-completion.js
@@ -0,0 +1,19 @@
+/* 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/>. */
+
+add_task(async function() {
+  const dbg = await initDebugger("doc-scroll-run-to-completion.html");
+  invokeInTab("pauseOnce", "doc-scroll-run-to-completion.html");
+  await waitForPaused(dbg);
+  assertPausedLocation(dbg);
+
+  const threadClient = dbg.toolbox.threadClient;
+  await checkEvaluateInTopFrame(threadClient, 'window.scrollBy(0, 10);', undefined);
+
+  // checkEvaluateInTopFrame does an implicit resume for some reason.
+  await waitForPaused(dbg);
+
+  resume(dbg);
+  await once(Services.ppmm, "test passed");
+});
new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-windowless-workers.js
@@ -0,0 +1,45 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test basic windowless worker functionality: the main thread and worker can be
+// separately controlled from the same debugger.
+add_task(async function() {
+  await pushPref("devtools.debugger.features.windowless-workers", true);
+
+  const dbg = await initDebugger("doc-windowless-workers.html");
+  const mainThread = dbg.toolbox.threadClient.actor;
+
+  const workers = await getWorkers(dbg);
+  ok(workers.length == 1, "Got one worker");
+  const workerThread = workers[0].actor;
+
+  const mainThreadSource = findSource(dbg, "doc-windowless-workers.html");
+  const workerSource = findSource(dbg, "simple-worker.js");
+
+  assertNotPaused(dbg);
+
+  await dbg.actions.breakOnNext();
+  await waitForPaused(dbg, "doc-windowless-workers.html");
+
+  // We should be paused at the timer in doc-windowless-workers.html
+  assertPausedAtSourceAndLine(dbg, mainThreadSource.id, 9);
+
+  await dbg.actions.selectThread(workerThread);
+  assertNotPaused(dbg);
+
+  await dbg.actions.breakOnNext();
+  await waitForPaused(dbg, "simple-worker.js");
+
+  // We should be paused at the timer in simple-worker.js
+  assertPausedAtSourceAndLine(dbg, workerSource.id, 3);
+
+  await stepOver(dbg);
+  assertPausedAtSourceAndLine(dbg, workerSource.id, 4);
+
+  await dbg.actions.selectThread(mainThread);
+
+  await stepOver(dbg);
+  assertPausedAtSourceAndLine(dbg, mainThreadSource.id, 10);
+});
new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/test/mochitest/examples/doc-scroll-run-to-completion.html
@@ -0,0 +1,27 @@
+ <!-- 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/. -->
+<!DOCTYPE html>
+<meta charset=UTF-8>
+<body></body>
+<script>
+const cpmm = SpecialPowers.Services.cpmm;
+var result;
+
+for (var i = 0; i < 100; i++) {
+var div = document.createElement("div");
+div.innerHTML = "Hello World!";
+document.body.insertBefore(div, document.body.firstChild);
+}
+
+async function pauseOnce() {
+    window.addEventListener('scroll', done);
+    result = "test failed";
+    debugger;
+    result = "test passed";
+}
+
+function done() {
+    cpmm.sendAsyncMessage(result);
+}
+</script>
new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/test/mochitest/examples/doc-windowless-workers.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+
+<script>
+var worker = new Worker("simple-worker.js");
+
+var count = 0;
+function timer() {
+  var n = ++count;
+  console.log("MAIN THREAD SAYS HELLO! " + n);
+}
+
+setInterval(timer, 1000);
+</script>
+
+<body>
+Hello World!
+</body>
+</html>
new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/test/mochitest/examples/simple-worker.js
@@ -0,0 +1,7 @@
+var count = 0;
+function timer() {
+  var n = ++count;
+  console.log("WORKER SAYS HELLO! " + n);
+}
+
+setInterval(timer, 1000);
--- a/devtools/client/debugger/new/test/mochitest/helpers.js
+++ b/devtools/client/debugger/new/test/mochitest/helpers.js
@@ -400,16 +400,44 @@ function assertHighlightLocation(dbg, so
 function isPaused(dbg) {
   const {
     selectors: { isPaused },
     getState
   } = dbg;
   return !!isPaused(getState());
 }
 
+// Make sure the debugger is paused at a certain source ID and line.
+function assertPausedAtSourceAndLine(dbg, expectedSourceId, expectedLine) {
+  assertPaused(dbg);
+
+  const {
+    selectors: { getWorkers, getFrames },
+    getState
+  } = dbg;
+
+  const frames = getFrames(getState());
+  ok(frames.length >= 1, "Got at least one frame");
+  const { sourceId, line } = frames[0].location;
+  ok(sourceId == expectedSourceId, "Frame has correct source");
+  ok(line == expectedLine, "Frame has correct line");
+}
+
+// Get any workers associated with the debugger.
+async function getWorkers(dbg) {
+  await dbg.actions.updateWorkers();
+
+  const {
+    selectors: { getWorkers },
+    getState
+  } = dbg;
+
+  return getWorkers(getState()).toJS();
+}
+
 async function waitForLoadedScopes(dbg) {
   const scopes = await waitForElement(dbg, "scopes");
   // Since scopes auto-expand, we can assume they are loaded when there is a tree node
   // with the aria-level attribute equal to "2".
   await waitUntil(() => scopes.querySelector(`.tree-node[aria-level="2"]`));
 }
 
 /**
--- a/devtools/client/webconsole/test/mochitest/browser.ini
+++ b/devtools/client/webconsole/test/mochitest/browser.ini
@@ -163,17 +163,17 @@ support-files =
   !/devtools/client/shared/test/test-actor-registry.js
 
 [browser_console.js]
 [browser_console_clear_cache.js]
 [browser_console_clear_method.js]
 skip-if = true # Bug 1437843
 [browser_console_consolejsm_output.js]
 [browser_console_context_menu_entries.js]
-skip-if = (os == "linux" && (debug || ccov)) # Bug 1440059
+skip-if = os == "linux" # Bug 1440059, disabled for all build types
 [browser_console_dead_objects.js]
 [browser_console_devtools_loader_exception.js]
 [browser_console_error_source_click.js]
 [browser_console_filters.js]
 [browser_console_jsterm_await.js]
 [browser_console_nsiconsolemessage.js]
 [browser_console_open_or_focus.js]
 skip-if = (verify && debug && (os == 'mac' || os == 'linux'))
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -8197,17 +8197,17 @@ bool nsContentUtils::IsThirdPartyWindowO
   }
 
   // In the absence of a window or channel, we assume that we are first-party.
   bool thirdParty = false;
 
   if (aWindow) {
     nsresult rv = thirdPartyUtil->IsThirdPartyWindow(aWindow->GetOuterWindow(),
                                                      aURI, &thirdParty);
-    if (NS_WARN_IF(NS_FAILED(rv))) {
+    if (NS_FAILED(rv)) {
       // Ideally we would do something similar to the channel code path here,
       // but existing code depends on this behaviour.
       return false;
     }
   }
 
   if (aChannel) {
     // Note, we must call IsThirdPartyChannel() here and not just try to
--- a/dom/html/test/mochitest.ini
+++ b/dom/html/test/mochitest.ini
@@ -531,17 +531,17 @@ skip-if = toolkit == 'android' #bug 8116
 [test_bug259332.html]
 [test_bug311681.html]
 [test_bug311681.xhtml]
 [test_bug324378.html]
 [test_bug332848.xhtml]
 [test_bug340017.xhtml]
 [test_bug359657.html]
 [test_bug369370.html]
-skip-if = toolkit == "android" || toolkit == "windows" # disabled on Windows because of bug 1234520
+skip-if = toolkit == "android" || toolkit == "windows" || os == 'linux' # disabled on Windows because of bug 1234520, disabled on linux bug 1258103
 [test_bug380383.html]
 [test_bug402680.html]
 [test_bug403868.html]
 [test_bug403868.xhtml]
 [test_bug435128.html]
 skip-if = true # Disabled for timeouts.
 [test_bug463104.html]
 [test_form-parsing.html]
rename from dom/smil/nsSMILFloatType.cpp
rename to dom/smil/SMILFloatType.cpp
--- a/dom/smil/nsSMILFloatType.cpp
+++ b/dom/smil/SMILFloatType.cpp
@@ -1,78 +1,81 @@
 /* -*- 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 "nsSMILFloatType.h"
+#include "SMILFloatType.h"
 #include "nsSMILValue.h"
 #include "nsDebug.h"
 #include <math.h>
 
-void nsSMILFloatType::Init(nsSMILValue& aValue) const {
+namespace mozilla {
+
+void SMILFloatType::Init(nsSMILValue& aValue) const {
   MOZ_ASSERT(aValue.IsNull(), "Unexpected value type");
   aValue.mU.mDouble = 0.0;
   aValue.mType = this;
 }
 
-void nsSMILFloatType::Destroy(nsSMILValue& aValue) const {
+void SMILFloatType::Destroy(nsSMILValue& aValue) const {
   MOZ_ASSERT(aValue.mType == this, "Unexpected SMIL value");
   aValue.mU.mDouble = 0.0;
   aValue.mType = nsSMILNullType::Singleton();
 }
 
-nsresult nsSMILFloatType::Assign(nsSMILValue& aDest,
-                                 const nsSMILValue& aSrc) const {
+nsresult SMILFloatType::Assign(nsSMILValue& aDest,
+                               const nsSMILValue& aSrc) const {
   MOZ_ASSERT(aDest.mType == aSrc.mType, "Incompatible SMIL types");
   MOZ_ASSERT(aDest.mType == this, "Unexpected SMIL value");
   aDest.mU.mDouble = aSrc.mU.mDouble;
   return NS_OK;
 }
 
-bool nsSMILFloatType::IsEqual(const nsSMILValue& aLeft,
-                              const nsSMILValue& aRight) const {
+bool SMILFloatType::IsEqual(const nsSMILValue& aLeft,
+                            const nsSMILValue& aRight) const {
   MOZ_ASSERT(aLeft.mType == aRight.mType, "Incompatible SMIL types");
   MOZ_ASSERT(aLeft.mType == this, "Unexpected type for SMIL value");
 
   return aLeft.mU.mDouble == aRight.mU.mDouble;
 }
 
-nsresult nsSMILFloatType::Add(nsSMILValue& aDest,
-                              const nsSMILValue& aValueToAdd,
-                              uint32_t aCount) const {
+nsresult SMILFloatType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd,
+                            uint32_t aCount) const {
   MOZ_ASSERT(aValueToAdd.mType == aDest.mType, "Trying to add invalid types");
   MOZ_ASSERT(aValueToAdd.mType == this, "Unexpected source type");
   aDest.mU.mDouble += aValueToAdd.mU.mDouble * aCount;
   return NS_OK;
 }
 
-nsresult nsSMILFloatType::ComputeDistance(const nsSMILValue& aFrom,
-                                          const nsSMILValue& aTo,
-                                          double& aDistance) const {
+nsresult SMILFloatType::ComputeDistance(const nsSMILValue& aFrom,
+                                        const nsSMILValue& aTo,
+                                        double& aDistance) const {
   MOZ_ASSERT(aFrom.mType == aTo.mType, "Trying to compare different types");
   MOZ_ASSERT(aFrom.mType == this, "Unexpected source type");
 
   const double& from = aFrom.mU.mDouble;
   const double& to = aTo.mU.mDouble;
 
   aDistance = fabs(to - from);
 
   return NS_OK;
 }
 
-nsresult nsSMILFloatType::Interpolate(const nsSMILValue& aStartVal,
-                                      const nsSMILValue& aEndVal,
-                                      double aUnitDistance,
-                                      nsSMILValue& aResult) const {
+nsresult SMILFloatType::Interpolate(const nsSMILValue& aStartVal,
+                                    const nsSMILValue& aEndVal,
+                                    double aUnitDistance,
+                                    nsSMILValue& aResult) const {
   MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
              "Trying to interpolate different types");
   MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
   MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
 
   const double& startVal = aStartVal.mU.mDouble;
   const double& endVal = aEndVal.mU.mDouble;
 
   aResult.mU.mDouble = (startVal + (endVal - startVal) * aUnitDistance);
 
   return NS_OK;
 }
+
+}  // namespace mozilla
rename from dom/smil/nsSMILFloatType.h
rename to dom/smil/SMILFloatType.h
--- a/dom/smil/nsSMILFloatType.h
+++ b/dom/smil/SMILFloatType.h
@@ -5,21 +5,23 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef NS_SMILFLOATTYPE_H_
 #define NS_SMILFLOATTYPE_H_
 
 #include "mozilla/Attributes.h"
 #include "nsISMILType.h"
 
-class nsSMILFloatType : public nsISMILType {
+namespace mozilla {
+
+class SMILFloatType : public nsISMILType {
  public:
   // Singleton for nsSMILValue objects to hold onto.
-  static nsSMILFloatType* Singleton() {
-    static nsSMILFloatType sSingleton;
+  static SMILFloatType* Singleton() {
+    static SMILFloatType sSingleton;
     return &sSingleton;
   }
 
  protected:
   // nsISMILType Methods
   // -------------------
   virtual void Init(nsSMILValue& aValue) const override;
   virtual void Destroy(nsSMILValue& aValue) const override;
@@ -33,12 +35,14 @@ class nsSMILFloatType : public nsISMILTy
                                    const nsSMILValue& aTo,
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal, double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
  private:
   // Private constructor: prevent instances beyond my singleton.
-  constexpr nsSMILFloatType() {}
+  constexpr SMILFloatType() {}
 };
 
+}  // namespace mozilla
+
 #endif  // NS_SMILFLOATTYPE_H_
--- a/dom/smil/moz.build
+++ b/dom/smil/moz.build
@@ -39,31 +39,31 @@ EXPORTS.mozilla.dom += [
 ]
 
 UNIFIED_SOURCES += [
     'nsSMILAnimationController.cpp',
     'nsSMILAnimationFunction.cpp',
     'nsSMILCompositor.cpp',
     'nsSMILCSSProperty.cpp',
     'nsSMILCSSValueType.cpp',
-    'nsSMILFloatType.cpp',
     'nsSMILInstanceTime.cpp',
     'nsSMILInterval.cpp',
     'nsSMILKeySpline.cpp',
     'nsSMILNullType.cpp',
     'nsSMILParserUtils.cpp',
     'nsSMILRepeatCount.cpp',
     'nsSMILSetAnimationFunction.cpp',
     'nsSMILTimeContainer.cpp',
     'nsSMILTimedElement.cpp',
     'nsSMILTimeValue.cpp',
     'nsSMILTimeValueSpec.cpp',
     'nsSMILValue.cpp',
     'SMILBoolType.cpp',
     'SMILEnumType.cpp',
+    'SMILFloatType.cpp',
     'SMILIntegerType.cpp',
     'SMILStringType.cpp',
     'TimeEvent.cpp',
 ]
 
 LOCAL_INCLUDES += [
     '/dom/base',
     '/dom/svg',
--- a/dom/svg/nsSVGLength2.cpp
+++ b/dom/svg/nsSVGLength2.cpp
@@ -6,17 +6,17 @@
 
 #include "mozilla/ArrayUtils.h"
 
 #include "nsSVGLength2.h"
 #include "mozilla/dom/SVGAnimatedLength.h"
 #include "mozilla/dom/SVGViewportElement.h"
 #include "nsContentUtils.h"  // NS_ENSURE_FINITE
 #include "nsIFrame.h"
-#include "nsSMILFloatType.h"
+#include "SMILFloatType.h"
 #include "nsSMILValue.h"
 #include "nsSVGAttrTearoffTable.h"
 #include "nsSVGIntegrationUtils.h"
 #include "nsTextFormatter.h"
 #include "DOMSVGLength.h"
 #include "LayoutLogging.h"
 
 using namespace mozilla;
@@ -431,41 +431,41 @@ nsresult nsSVGLength2::SMILLength::Value
     nsSMILValue& aValue, bool& aPreventCachingOfSandwich) const {
   float value;
   uint16_t unitType;
 
   if (!GetValueFromString(aStr, value, &unitType)) {
     return NS_ERROR_DOM_SYNTAX_ERR;
   }
 
-  nsSMILValue val(nsSMILFloatType::Singleton());
+  nsSMILValue val(SMILFloatType::Singleton());
   val.mU.mDouble = value * mVal->GetPixelsPerUnit(mSVGElement, unitType);
   aValue = val;
   aPreventCachingOfSandwich =
       (unitType == SVGLength_Binding::SVG_LENGTHTYPE_PERCENTAGE ||
        unitType == SVGLength_Binding::SVG_LENGTHTYPE_EMS ||
        unitType == SVGLength_Binding::SVG_LENGTHTYPE_EXS);
 
   return NS_OK;
 }
 
 nsSMILValue nsSVGLength2::SMILLength::GetBaseValue() const {
-  nsSMILValue val(nsSMILFloatType::Singleton());
+  nsSMILValue val(SMILFloatType::Singleton());
   val.mU.mDouble = mVal->GetBaseValue(mSVGElement);
   return val;
 }
 
 void nsSVGLength2::SMILLength::ClearAnimValue() {
   if (mVal->mIsAnimated) {
     mVal->mIsAnimated = false;
     mVal->mAnimVal = mVal->mBaseVal;
     mSVGElement->DidAnimateLength(mVal->mAttrEnum);
   }
 }
 
 nsresult nsSVGLength2::SMILLength::SetAnimValue(const nsSMILValue& aValue) {
-  NS_ASSERTION(aValue.mType == nsSMILFloatType::Singleton(),
+  NS_ASSERTION(aValue.mType == SMILFloatType::Singleton(),
                "Unexpected type to assign animated value");
-  if (aValue.mType == nsSMILFloatType::Singleton()) {
+  if (aValue.mType == SMILFloatType::Singleton()) {
     return mVal->SetAnimValue(float(aValue.mU.mDouble), mSVGElement);
   }
   return NS_OK;
 }
--- a/dom/svg/nsSVGNumber2.cpp
+++ b/dom/svg/nsSVGNumber2.cpp
@@ -2,17 +2,17 @@
 /* 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 "nsSVGNumber2.h"
 #include "mozilla/Attributes.h"
 #include "nsContentUtils.h"  // NS_ENSURE_FINITE
-#include "nsSMILFloatType.h"
+#include "SMILFloatType.h"
 #include "nsSMILValue.h"
 #include "nsSVGAttrTearoffTable.h"
 #include "SVGContentUtils.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 /* Implementation */
@@ -121,38 +121,38 @@ nsresult nsSVGNumber2::SMILNumber::Value
   float value;
 
   if (!GetValueFromString(
           aStr, mSVGElement->NumberAttrAllowsPercentage(mVal->mAttrEnum),
           value)) {
     return NS_ERROR_DOM_SYNTAX_ERR;
   }
 
-  nsSMILValue val(nsSMILFloatType::Singleton());
+  nsSMILValue val(SMILFloatType::Singleton());
   val.mU.mDouble = value;
   aValue = val;
   aPreventCachingOfSandwich = false;
 
   return NS_OK;
 }
 
 nsSMILValue nsSVGNumber2::SMILNumber::GetBaseValue() const {
-  nsSMILValue val(nsSMILFloatType::Singleton());
+  nsSMILValue val(SMILFloatType::Singleton());
   val.mU.mDouble = mVal->mBaseVal;
   return val;
 }
 
 void nsSVGNumber2::SMILNumber::ClearAnimValue() {
   if (mVal->mIsAnimated) {
     mVal->mIsAnimated = false;
     mVal->mAnimVal = mVal->mBaseVal;
     mSVGElement->DidAnimateNumber(mVal->mAttrEnum);
   }
 }
 
 nsresult nsSVGNumber2::SMILNumber::SetAnimValue(const nsSMILValue& aValue) {
-  NS_ASSERTION(aValue.mType == nsSMILFloatType::Singleton(),
+  NS_ASSERTION(aValue.mType == SMILFloatType::Singleton(),
                "Unexpected type to assign animated value");
-  if (aValue.mType == nsSMILFloatType::Singleton()) {
+  if (aValue.mType == SMILFloatType::Singleton()) {
     mVal->SetAnimValue(float(aValue.mU.mDouble), mSVGElement);
   }
   return NS_OK;
 }
--- a/toolkit/moz.configure
+++ b/toolkit/moz.configure
@@ -1083,18 +1083,17 @@ def midl_names(c_compiler, toolchain_pre
 def check_for_midl(target, compile_environment):
     if target.os != 'WINNT':
         return
 
     if compile_environment:
         return True
 
 
-midl = check_prog('MIDL', midl_names, when=check_for_midl, allow_missing=True,
-                  paths=sdk_bin_path)
+midl = check_prog('MIDL', midl_names, when=check_for_midl, allow_missing=True)
 
 
 @depends(c_compiler, target, when=depends(midl, target)(lambda m, t: m and t.kernel == 'WINNT'))
 def midl_flags(c_compiler, target):
     if c_compiler and c_compiler.type in ('msvc', 'clang-cl'):
         env = {
             'x86': 'win32',
             'x86_64': 'x64',
@@ -1271,18 +1270,17 @@ option('--enable-layout-debugger',
 set_config('MOZ_LAYOUT_DEBUGGER', depends_if('--enable-layout-debugger')(lambda _: True))
 
 
 # Shader Compiler for Windows (and MinGW Cross Compile)
 # ==============================================================
 
 with only_when(compile_environment):
     fxc = check_prog('FXC', ('fxc.exe', 'fxc2.exe'), when=depends(target)
-                     (lambda t: t.kernel == 'WINNT'),
-                     paths=sdk_bin_path)
+                     (lambda t: t.kernel == 'WINNT'))
     wine = check_prog('WINE', ['wine'], when=depends(target, host)
                       (lambda t, h: t.kernel == 'WINNT' and h.kernel == 'Linux'))
 
 
 # VPX
 # ===
 
 with only_when(compile_environment):