Bug 1489454 - Remove all trailing whitespaces (again) r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Fri, 07 Sep 2018 14:47:51 +0000
changeset 435254 10d5143647cfda21649cf254adcb21d116524c5d
parent 435253 6923b7cb526e9f574099f1d503621a884d9c7392
child 435263 0e957ded091e36c8af71ec7a175274f550a14b9b
push id68954
push usersledru@mozilla.com
push dateFri, 07 Sep 2018 22:05:44 +0000
treeherderautoland@10d5143647cf [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1489454
milestone64.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
Bug 1489454 - Remove all trailing whitespaces (again) r=Ehsan This also includes moving some files to the regular format. Differential Revision: https://phabricator.services.mozilla.com/D5249
accessible/base/nsAccUtils.h
accessible/generic/DocAccessible.cpp
accessible/ipc/win/handler/HandlerChildEnumerator.cpp
accessible/ipc/win/handler/HandlerTextLeaf.cpp
docshell/base/nsDSURIContentListener.cpp
docshell/base/nsDocShell.cpp
dom/base/CharacterData.cpp
dom/base/Element.h
dom/base/Link.cpp
dom/base/Location.cpp
dom/base/nsContentPolicy.h
dom/base/nsGlobalWindowOuter.h
dom/base/nsIGlobalObject.cpp
dom/bindings/FakeString.h
dom/canvas/WebGLContext.cpp
dom/canvas/WebGLContextDraw.cpp
dom/events/ContentEventHandler.cpp
dom/events/EventStateManager.cpp
dom/events/EventTarget.h
dom/file/uri/BlobURLProtocolHandler.h
dom/html/nsGenericHTMLElement.cpp
dom/html/nsHTMLDocument.cpp
dom/plugins/ipc/FunctionBroker.h
dom/plugins/ipc/FunctionBrokerChild.cpp
dom/plugins/ipc/FunctionBrokerIPCUtils.cpp
dom/plugins/ipc/FunctionBrokerIPCUtils.h
dom/plugins/ipc/FunctionBrokerParent.cpp
dom/plugins/ipc/FunctionBrokerParent.h
dom/plugins/ipc/FunctionBrokerThread.h
dom/plugins/ipc/IpdlTuple.h
dom/security/nsContentSecurityManager.cpp
dom/smil/nsSMILKeySpline.h
dom/xml/nsXMLContentSink.h
hal/android/AndroidHal.cpp
image/decoders/nsICODecoder.cpp
intl/locale/DateTimeFormat.h
layout/base/nsLayoutUtils.cpp
layout/generic/nsQueryFrame.h
layout/style/ServoCSSRuleList.cpp
layout/tables/nsTableCellFrame.cpp
layout/tables/nsTableCellFrame.h
layout/xul/nsTextBoxFrame.cpp
layout/xul/tree/TreeBoxObject.cpp
layout/xul/tree/nsTreeColumns.cpp
modules/libmar/sign/mar_sign.c
modules/libmar/sign/nss_secutil.c
modules/libmar/src/mar.h
modules/libmar/src/mar_cmdline.h
modules/libmar/src/mar_create.c
modules/libmar/src/mar_private.h
modules/libmar/src/mar_read.c
modules/libmar/tool/mar.c
modules/libmar/verify/cryptox.c
modules/libmar/verify/cryptox.h
modules/libmar/verify/mar_verify.c
modules/libpref/test/gtest/Parser.cpp
netwerk/base/nsURLParsers.cpp
netwerk/ipc/NeckoMessageUtils.h
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/http/nsHttpTransaction.cpp
xpcom/string/nsReadableUtils.h
--- a/accessible/base/nsAccUtils.h
+++ b/accessible/base/nsAccUtils.h
@@ -137,17 +137,17 @@ public:
 
   static Accessible* TableFor(Accessible* aRow);
 
   /**
    * Return true if the DOM node of a given accessible has a given attribute
    * with a value of "true".
    */
   static bool IsDOMAttrTrue(const Accessible* aAccessible, nsAtom* aAttr);
-  
+
   /**
    * Return true if the DOM node of given accessible has aria-selected="true"
    * attribute.
    */
   static inline bool IsARIASelected(const Accessible* aAccessible) {
     return IsDOMAttrTrue(aAccessible, nsGkAtoms::aria_selected);
   }
 
--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -2511,14 +2511,14 @@ DocAccessible::ARIAActiveDescendantIDMay
     return;
   }
 
   // The aria-activedescendant target has probably changed.
   Accessible* acc = GetAccessibleEvenIfNotInMapOrContainer(focusNode);
   if (!acc) {
     return;
   }
-  
+
   // The active descendant might have just been inserted and may not be in the
   // tree yet. Therefore, schedule this async to ensure the tree is up to date.
   mNotificationController->ScheduleNotification<DocAccessible, Accessible>
     (this, &DocAccessible::ARIAActiveDescendantChanged, acc);
 }
--- a/accessible/ipc/win/handler/HandlerChildEnumerator.cpp
+++ b/accessible/ipc/win/handler/HandlerChildEnumerator.cpp
@@ -1,183 +1,183 @@
-/* -*- 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/. */
-
-#if defined(MOZILLA_INTERNAL_API)
-#error This code is NOT for internal Gecko use!
-#endif // defined(MOZILLA_INTERNAL_API)
-
-#include "HandlerChildEnumerator.h"
-#include "HandlerTextLeaf.h"
-#include "mozilla/Assertions.h"
-
-namespace mozilla {
-namespace a11y {
-
-HandlerChildEnumerator::HandlerChildEnumerator(AccessibleHandler* aHandler,
-    IGeckoBackChannel* aGeckoBackChannel)
-  : mHandler(aHandler)
-  , mGeckoBackChannel(aGeckoBackChannel)
-  , mChildCount(0)
-  , mNextChild(0)
-{
-  MOZ_ASSERT(aHandler);
-  MOZ_ASSERT(aGeckoBackChannel);
-}
-
-HandlerChildEnumerator::HandlerChildEnumerator(
-    const HandlerChildEnumerator& aEnumerator)
-  : mHandler(aEnumerator.mHandler)
-  , mGeckoBackChannel(aEnumerator.mGeckoBackChannel)
-  , mChildCount(aEnumerator.mChildCount)
-  , mNextChild(aEnumerator.mNextChild)
-{
-  if (mChildCount == 0) {
-    return;
-  }
-  mChildren = MakeUnique<VARIANT[]>(mChildCount);
-  CopyMemory(mChildren.get(), aEnumerator.mChildren.get(),
-             sizeof(VARIANT) * mChildCount);
-  for (ULONG index = 0; index < mChildCount; ++index) {
-    mChildren[index].pdispVal->AddRef();
-  }
-}
-
-HandlerChildEnumerator::~HandlerChildEnumerator()
-{
-  ClearCache();
-}
-
-void
-HandlerChildEnumerator::ClearCache()
-{
-  if (!mChildren) {
-    return;
-  }
-
-  for (ULONG index = 0; index < mChildCount; ++index) {
-    mChildren[index].pdispVal->Release();
-  }
-
-  mChildren = nullptr;
-  mChildCount = 0;
-}
-
-HRESULT
-HandlerChildEnumerator::MaybeCacheChildren()
-{
-  if (mChildren) {
-    // Already cached.
-    return S_OK;
-  }
-
-  AccChildData* children;
-  HRESULT hr = mGeckoBackChannel->get_AllChildren(&children, &mChildCount);
-  if (FAILED(hr)) {
-    mChildCount = 0;
-    ClearCache();
-    return hr;
-  }
-
-  HWND hwnd = nullptr;
-  hr = mHandler->get_windowHandle(&hwnd);
-  MOZ_ASSERT(SUCCEEDED(hr));
-
-  RefPtr<IDispatch> parent;
-  hr = mHandler->QueryInterface(IID_IDispatch, getter_AddRefs(parent));
-  MOZ_ASSERT(SUCCEEDED(hr));
-
-  mChildren = MakeUnique<VARIANT[]>(mChildCount);
-  for (ULONG index = 0; index < mChildCount; ++index) {
-    AccChildData& data = children[index];
-    VARIANT& child = mChildren[index];
-    if (data.mAccessible) {
-      RefPtr<IDispatch> disp;
-      hr = data.mAccessible->QueryInterface(IID_IDispatch,
-                                            getter_AddRefs(disp));
-      data.mAccessible->Release();
-      MOZ_ASSERT(SUCCEEDED(hr));
-      if (FAILED(hr)) {
-        child.vt = VT_EMPTY;
-        continue;
-      }
-      child.vt = VT_DISPATCH;
-      disp.forget(&child.pdispVal);
-    } else {
-      // Text leaf.
-      RefPtr<IDispatch> leaf(
-        new HandlerTextLeaf(parent, index, hwnd, data));
-      child.vt = VT_DISPATCH;
-      leaf.forget(&child.pdispVal);
-    }
-  }
-
-  ::CoTaskMemFree(children);
-  return S_OK;
-}
-
-IMPL_IUNKNOWN_QUERY_HEAD(HandlerChildEnumerator)
-IMPL_IUNKNOWN_QUERY_IFACE(IEnumVARIANT)
-IMPL_IUNKNOWN_QUERY_TAIL_AGGREGATED(mHandler)
-
-/*** IEnumVARIANT ***/
-
-HRESULT
-HandlerChildEnumerator::Clone(IEnumVARIANT** aPpEnum)
-{
-  RefPtr<HandlerChildEnumerator> newEnum(new HandlerChildEnumerator(*this));
-  newEnum.forget(aPpEnum);
-  return S_OK;
-}
-
-HRESULT
-HandlerChildEnumerator::Next(ULONG aCelt, VARIANT* aRgVar,
-                             ULONG* aPCeltFetched)
-{
-  if (!aRgVar || aCelt == 0) {
-    return E_INVALIDARG;
-  }
-
-  HRESULT hr = MaybeCacheChildren();
-  if (FAILED(hr)) {
-    return hr;
-  }
-
-  for (ULONG index = 0; index < aCelt; ++index) {
-    if (mNextChild >= mChildCount) {
-      // Less elements remaining than were requested.
-      if (aPCeltFetched) {
-        *aPCeltFetched = index;
-      }
-      return S_FALSE;
-    }
-    aRgVar[index] = mChildren[mNextChild];
-    aRgVar[index].pdispVal->AddRef();
-    ++mNextChild;
-  }
-  *aPCeltFetched = aCelt;
-  return S_OK;
-}
-
-HRESULT
-HandlerChildEnumerator::Reset()
-{
-  mNextChild = 0;
-  ClearCache();
-  return S_OK;
-}
-
-HRESULT
-HandlerChildEnumerator::Skip(ULONG aCelt)
-{
-  mNextChild += aCelt;
-  if (mNextChild > mChildCount) {
-    // Less elements remaining than the client requested to skip.
-    return S_FALSE;
-  }
-  return S_OK;
-}
-
-} // namespace a11y
-} // namespace mozilla
+/* -*- 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/. */
+
+#if defined(MOZILLA_INTERNAL_API)
+#error This code is NOT for internal Gecko use!
+#endif // defined(MOZILLA_INTERNAL_API)
+
+#include "HandlerChildEnumerator.h"
+#include "HandlerTextLeaf.h"
+#include "mozilla/Assertions.h"
+
+namespace mozilla {
+namespace a11y {
+
+HandlerChildEnumerator::HandlerChildEnumerator(AccessibleHandler* aHandler,
+    IGeckoBackChannel* aGeckoBackChannel)
+  : mHandler(aHandler)
+  , mGeckoBackChannel(aGeckoBackChannel)
+  , mChildCount(0)
+  , mNextChild(0)
+{
+  MOZ_ASSERT(aHandler);
+  MOZ_ASSERT(aGeckoBackChannel);
+}
+
+HandlerChildEnumerator::HandlerChildEnumerator(
+    const HandlerChildEnumerator& aEnumerator)
+  : mHandler(aEnumerator.mHandler)
+  , mGeckoBackChannel(aEnumerator.mGeckoBackChannel)
+  , mChildCount(aEnumerator.mChildCount)
+  , mNextChild(aEnumerator.mNextChild)
+{
+  if (mChildCount == 0) {
+    return;
+  }
+  mChildren = MakeUnique<VARIANT[]>(mChildCount);
+  CopyMemory(mChildren.get(), aEnumerator.mChildren.get(),
+             sizeof(VARIANT) * mChildCount);
+  for (ULONG index = 0; index < mChildCount; ++index) {
+    mChildren[index].pdispVal->AddRef();
+  }
+}
+
+HandlerChildEnumerator::~HandlerChildEnumerator()
+{
+  ClearCache();
+}
+
+void
+HandlerChildEnumerator::ClearCache()
+{
+  if (!mChildren) {
+    return;
+  }
+
+  for (ULONG index = 0; index < mChildCount; ++index) {
+    mChildren[index].pdispVal->Release();
+  }
+
+  mChildren = nullptr;
+  mChildCount = 0;
+}
+
+HRESULT
+HandlerChildEnumerator::MaybeCacheChildren()
+{
+  if (mChildren) {
+    // Already cached.
+    return S_OK;
+  }
+
+  AccChildData* children;
+  HRESULT hr = mGeckoBackChannel->get_AllChildren(&children, &mChildCount);
+  if (FAILED(hr)) {
+    mChildCount = 0;
+    ClearCache();
+    return hr;
+  }
+
+  HWND hwnd = nullptr;
+  hr = mHandler->get_windowHandle(&hwnd);
+  MOZ_ASSERT(SUCCEEDED(hr));
+
+  RefPtr<IDispatch> parent;
+  hr = mHandler->QueryInterface(IID_IDispatch, getter_AddRefs(parent));
+  MOZ_ASSERT(SUCCEEDED(hr));
+
+  mChildren = MakeUnique<VARIANT[]>(mChildCount);
+  for (ULONG index = 0; index < mChildCount; ++index) {
+    AccChildData& data = children[index];
+    VARIANT& child = mChildren[index];
+    if (data.mAccessible) {
+      RefPtr<IDispatch> disp;
+      hr = data.mAccessible->QueryInterface(IID_IDispatch,
+                                            getter_AddRefs(disp));
+      data.mAccessible->Release();
+      MOZ_ASSERT(SUCCEEDED(hr));
+      if (FAILED(hr)) {
+        child.vt = VT_EMPTY;
+        continue;
+      }
+      child.vt = VT_DISPATCH;
+      disp.forget(&child.pdispVal);
+    } else {
+      // Text leaf.
+      RefPtr<IDispatch> leaf(
+        new HandlerTextLeaf(parent, index, hwnd, data));
+      child.vt = VT_DISPATCH;
+      leaf.forget(&child.pdispVal);
+    }
+  }
+
+  ::CoTaskMemFree(children);
+  return S_OK;
+}
+
+IMPL_IUNKNOWN_QUERY_HEAD(HandlerChildEnumerator)
+IMPL_IUNKNOWN_QUERY_IFACE(IEnumVARIANT)
+IMPL_IUNKNOWN_QUERY_TAIL_AGGREGATED(mHandler)
+
+/*** IEnumVARIANT ***/
+
+HRESULT
+HandlerChildEnumerator::Clone(IEnumVARIANT** aPpEnum)
+{
+  RefPtr<HandlerChildEnumerator> newEnum(new HandlerChildEnumerator(*this));
+  newEnum.forget(aPpEnum);
+  return S_OK;
+}
+
+HRESULT
+HandlerChildEnumerator::Next(ULONG aCelt, VARIANT* aRgVar,
+                             ULONG* aPCeltFetched)
+{
+  if (!aRgVar || aCelt == 0) {
+    return E_INVALIDARG;
+  }
+
+  HRESULT hr = MaybeCacheChildren();
+  if (FAILED(hr)) {
+    return hr;
+  }
+
+  for (ULONG index = 0; index < aCelt; ++index) {
+    if (mNextChild >= mChildCount) {
+      // Less elements remaining than were requested.
+      if (aPCeltFetched) {
+        *aPCeltFetched = index;
+      }
+      return S_FALSE;
+    }
+    aRgVar[index] = mChildren[mNextChild];
+    aRgVar[index].pdispVal->AddRef();
+    ++mNextChild;
+  }
+  *aPCeltFetched = aCelt;
+  return S_OK;
+}
+
+HRESULT
+HandlerChildEnumerator::Reset()
+{
+  mNextChild = 0;
+  ClearCache();
+  return S_OK;
+}
+
+HRESULT
+HandlerChildEnumerator::Skip(ULONG aCelt)
+{
+  mNextChild += aCelt;
+  if (mNextChild > mChildCount) {
+    // Less elements remaining than the client requested to skip.
+    return S_FALSE;
+  }
+  return S_OK;
+}
+
+} // namespace a11y
+} // namespace mozilla
--- a/accessible/ipc/win/handler/HandlerTextLeaf.cpp
+++ b/accessible/ipc/win/handler/HandlerTextLeaf.cpp
@@ -1,402 +1,402 @@
-/* -*- 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/. */
-
-#if defined(MOZILLA_INTERNAL_API)
-#error This code is NOT for internal Gecko use!
-#endif // defined(MOZILLA_INTERNAL_API)
-
-#include "HandlerTextLeaf.h"
-#include "mozilla/Assertions.h"
-
-namespace mozilla {
-namespace a11y {
-
-HandlerTextLeaf::HandlerTextLeaf(IDispatch* aParent,
-                                 long aIndexInParent, HWND aHwnd,
-                                 AccChildData& aData)
-: mParent(aParent)
-, mIndexInParent(aIndexInParent)
-, mHwnd(aHwnd)
-, mData(aData)
-{
-  MOZ_ASSERT(aParent);
-}
-
-HandlerTextLeaf::~HandlerTextLeaf()
-{
-  if (mData.mText) {
-    ::SysFreeString(mData.mText);
-  }
-}
-
-IMPL_IUNKNOWN_QUERY_HEAD(HandlerTextLeaf)
-IMPL_IUNKNOWN_QUERY_IFACE(IDispatch)
-IMPL_IUNKNOWN_QUERY_IFACE(IAccessible)
-IMPL_IUNKNOWN_QUERY_IFACE(IAccessible2)
-IMPL_IUNKNOWN_QUERY_IFACE(IServiceProvider)
-IMPL_IUNKNOWN_QUERY_TAIL
-
-/*** IDispatch ***/
-
-HRESULT
-HandlerTextLeaf::GetTypeInfoCount(UINT *pctinfo)
-{
-  return E_NOTIMPL;
-}
-
+/* -*- 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/. */
+
+#if defined(MOZILLA_INTERNAL_API)
+#error This code is NOT for internal Gecko use!
+#endif // defined(MOZILLA_INTERNAL_API)
+
+#include "HandlerTextLeaf.h"
+#include "mozilla/Assertions.h"
+
+namespace mozilla {
+namespace a11y {
+
+HandlerTextLeaf::HandlerTextLeaf(IDispatch* aParent,
+                                 long aIndexInParent, HWND aHwnd,
+                                 AccChildData& aData)
+: mParent(aParent)
+, mIndexInParent(aIndexInParent)
+, mHwnd(aHwnd)
+, mData(aData)
+{
+  MOZ_ASSERT(aParent);
+}
+
+HandlerTextLeaf::~HandlerTextLeaf()
+{
+  if (mData.mText) {
+    ::SysFreeString(mData.mText);
+  }
+}
+
+IMPL_IUNKNOWN_QUERY_HEAD(HandlerTextLeaf)
+IMPL_IUNKNOWN_QUERY_IFACE(IDispatch)
+IMPL_IUNKNOWN_QUERY_IFACE(IAccessible)
+IMPL_IUNKNOWN_QUERY_IFACE(IAccessible2)
+IMPL_IUNKNOWN_QUERY_IFACE(IServiceProvider)
+IMPL_IUNKNOWN_QUERY_TAIL
+
+/*** IDispatch ***/
+
+HRESULT
+HandlerTextLeaf::GetTypeInfoCount(UINT *pctinfo)
+{
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
-HandlerTextLeaf::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
+HandlerTextLeaf::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
                                LCID lcid, DISPID *rgDispId)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
-                        WORD wFlags, DISPPARAMS *pDispParams,
-                        VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
+HandlerTextLeaf::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
+                        WORD wFlags, DISPPARAMS *pDispParams,
+                        VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
                         UINT *puArgErr)
 {
-  return E_NOTIMPL;
-}
-
-/*** IAccessible ***/
-
+  return E_NOTIMPL;
+}
+
+/*** IAccessible ***/
+
 HRESULT
 HandlerTextLeaf::get_accParent(IDispatch **ppdispParent)
-{
-  if (!ppdispParent) {
-    return E_INVALIDARG;
-  }
-
-  RefPtr<IDispatch> parent(mParent);
-  parent.forget(ppdispParent);
+{
+  if (!ppdispParent) {
+    return E_INVALIDARG;
+  }
+
+  RefPtr<IDispatch> parent(mParent);
+  parent.forget(ppdispParent);
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accChildCount(long *pcountChildren)
-{
-  if (!pcountChildren) {
-    return E_INVALIDARG;
-  }
-
-  *pcountChildren = 0;
+{
+  if (!pcountChildren) {
+    return E_INVALIDARG;
+  }
+
+  *pcountChildren = 0;
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accChild(VARIANT varChild, IDispatch **ppdispChild)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accName(VARIANT varChild, BSTR *pszName)
-{
-  if (varChild.lVal != CHILDID_SELF || !pszName) {
-    return E_INVALIDARG;
-  }
-
-  *pszName = CopyBSTR(mData.mText);
+{
+  if (varChild.lVal != CHILDID_SELF || !pszName) {
+    return E_INVALIDARG;
+  }
+
+  *pszName = CopyBSTR(mData.mText);
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accValue(VARIANT varChild, BSTR *pszValue)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accDescription(VARIANT varChild, BSTR *pszDescription)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accRole(VARIANT varChild, VARIANT *pvarRole)
-{
-  if (varChild.lVal != CHILDID_SELF || !pvarRole) {
-    return E_INVALIDARG;
-  }
-
-  pvarRole->vt = VT_I4;
-  pvarRole->lVal = mData.mTextRole;
+{
+  if (varChild.lVal != CHILDID_SELF || !pvarRole) {
+    return E_INVALIDARG;
+  }
+
+  pvarRole->vt = VT_I4;
+  pvarRole->lVal = mData.mTextRole;
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accState(VARIANT varChild, VARIANT *pvarState)
 {
-  if (varChild.lVal != CHILDID_SELF || !pvarState) {
-    return E_INVALIDARG;
-  }
-
-  pvarState->vt = VT_I4;
-  pvarState->lVal = mData.mTextState;
-  return S_OK;
-}
-
+  if (varChild.lVal != CHILDID_SELF || !pvarState) {
+    return E_INVALIDARG;
+  }
+
+  pvarState->vt = VT_I4;
+  pvarState->lVal = mData.mTextState;
+  return S_OK;
+}
+
 HRESULT
 HandlerTextLeaf::get_accHelp(VARIANT varChild, BSTR *pszHelp)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
-HandlerTextLeaf::get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild,
+HandlerTextLeaf::get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild,
                                   long *pidTopic)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
-HandlerTextLeaf::get_accKeyboardShortcut(VARIANT varChild,
+HandlerTextLeaf::get_accKeyboardShortcut(VARIANT varChild,
                                          BSTR *pszKeyboardShortcut)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_accFocus(VARIANT *pvarChild)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::get_accSelection(VARIANT *pvarChildren)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::get_accDefaultAction(VARIANT varChild,
+HandlerTextLeaf::get_accDefaultAction(VARIANT varChild,
                                       BSTR *pszDefaultAction)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::accSelect(long flagsSelect, VARIANT varChild)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::accLocation(long *pxLeft, long *pyTop, long *pcxWidth,
+HandlerTextLeaf::accLocation(long *pxLeft, long *pyTop, long *pcxWidth,
                              long *pcyHeight, VARIANT varChild)
-{
-  if (varChild.lVal != CHILDID_SELF || !pxLeft || !pyTop || !pcxWidth ||
-      !pcyHeight) {
-    return E_INVALIDARG;
-  }
-
-  *pxLeft = mData.mTextLeft;
-  *pyTop = mData.mTextTop;
-  *pcxWidth = mData.mTextWidth;
-  *pcyHeight = mData.mTextHeight;
+{
+  if (varChild.lVal != CHILDID_SELF || !pxLeft || !pyTop || !pcxWidth ||
+      !pcyHeight) {
+    return E_INVALIDARG;
+  }
+
+  *pxLeft = mData.mTextLeft;
+  *pyTop = mData.mTextTop;
+  *pcxWidth = mData.mTextWidth;
+  *pcyHeight = mData.mTextHeight;
   return S_OK;
-}
-
+}
+
 HRESULT
-HandlerTextLeaf::accNavigate(long navDir, VARIANT varStart,
+HandlerTextLeaf::accNavigate(long navDir, VARIANT varStart,
                              VARIANT *pvarEndUpAt)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::accHitTest( long xLeft, long yTop, VARIANT *pvarChild)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::accDoDefaultAction(VARIANT varChild)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::put_accName(VARIANT varChild, BSTR szName)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::put_accValue(VARIANT varChild, BSTR szValue)
 {
-  return E_NOTIMPL;
-}
-
-/*** IAccessible2 ***/
-
+  return E_NOTIMPL;
+}
+
+/*** IAccessible2 ***/
+
 HRESULT
 HandlerTextLeaf::get_nRelations(long* nRelations)
-{
-  return E_NOTIMPL;
-}
-
+{
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::get_relation(long relationIndex,
+HandlerTextLeaf::get_relation(long relationIndex,
                               IAccessibleRelation** relation)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::get_relations(long maxRelations,
-                               IAccessibleRelation** relations,
+HandlerTextLeaf::get_relations(long maxRelations,
+                               IAccessibleRelation** relations,
                                long* nRelations)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::role(long* role)
-{
-  if (!role) {
-    return E_INVALIDARG;
-  }
-
-  *role = mData.mTextRole;
+{
+  if (!role) {
+    return E_INVALIDARG;
+  }
+
+  *role = mData.mTextRole;
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::scrollTo(IA2ScrollType scrollType)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
-HandlerTextLeaf::scrollToPoint(IA2CoordinateType coordinateType, long x,
+HandlerTextLeaf::scrollToPoint(IA2CoordinateType coordinateType, long x,
                                long y)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::get_groupPosition(long* groupLevel, long* similarItemsInGroup,
+HandlerTextLeaf::get_groupPosition(long* groupLevel, long* similarItemsInGroup,
                                    long* positionInGroup)
-{
-  return E_NOTIMPL;
-}
-
+{
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::get_states(AccessibleStates* states)
-{
-  if (!states) {
-    return E_INVALIDARG;
-  }
-
-  *states = 0;
+{
+  if (!states) {
+    return E_INVALIDARG;
+  }
+
+  *states = 0;
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_extendedRole(BSTR* extendedRole)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::get_localizedExtendedRole(BSTR* localizedExtendedRole)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::get_nExtendedStates(long* nExtendedStates)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::get_extendedStates(long maxExtendedStates,
-                                    BSTR** extendedStates,
+HandlerTextLeaf::get_extendedStates(long maxExtendedStates,
+                                    BSTR** extendedStates,
                                     long* nExtendedStates)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
-HandlerTextLeaf::get_localizedExtendedStates(long maxLocalizedExtendedStates,
-                                             BSTR** localizedExtendedStates,
+HandlerTextLeaf::get_localizedExtendedStates(long maxLocalizedExtendedStates,
+                                             BSTR** localizedExtendedStates,
                                              long* nLocalizedExtendedStates)
 {
-  return E_NOTIMPL;
-}
-
+  return E_NOTIMPL;
+}
+
 HRESULT
 HandlerTextLeaf::get_uniqueID(long* uniqueID)
-{
-  if (!uniqueID) {
-    return E_INVALIDARG;
-  }
-
-  *uniqueID = mData.mTextId;
+{
+  if (!uniqueID) {
+    return E_INVALIDARG;
+  }
+
+  *uniqueID = mData.mTextId;
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_windowHandle(HWND* windowHandle)
-{
-  if (!windowHandle) {
-    return E_INVALIDARG;
-  }
-
-  *windowHandle = mHwnd;
+{
+  if (!windowHandle) {
+    return E_INVALIDARG;
+  }
+
+  *windowHandle = mHwnd;
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_indexInParent(long* indexInParent)
-{
-  if (!indexInParent) {
-    return E_INVALIDARG;
-  }
-
-  *indexInParent = mIndexInParent;
+{
+  if (!indexInParent) {
+    return E_INVALIDARG;
+  }
+
+  *indexInParent = mIndexInParent;
   return S_OK;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_locale(IA2Locale* locale)
-{
+{
   return E_NOTIMPL;
-}
-
+}
+
 HRESULT
 HandlerTextLeaf::get_attributes(BSTR* attributes)
-{
+{
   return E_NOTIMPL;
-}
-
-/*** IServiceProvider ***/
-
+}
+
+/*** IServiceProvider ***/
+
 HRESULT
-HandlerTextLeaf::QueryService(REFGUID aServiceId, REFIID aIid,
+HandlerTextLeaf::QueryService(REFGUID aServiceId, REFIID aIid,
                               void** aOutInterface)
-{
-  if (aIid == IID_IAccessible2) {
-    RefPtr<IAccessible2> ia2(this);
-    ia2.forget(aOutInterface);
-    return S_OK;
-  }
-
+{
+  if (aIid == IID_IAccessible2) {
+    RefPtr<IAccessible2> ia2(this);
+    ia2.forget(aOutInterface);
+    return S_OK;
+  }
+
   return E_INVALIDARG;
-}
-
-} // namespace a11y
-} // namespace mozilla
+}
+
+} // namespace a11y
+} // namespace mozilla
--- a/docshell/base/nsDSURIContentListener.cpp
+++ b/docshell/base/nsDSURIContentListener.cpp
@@ -161,17 +161,17 @@ nsDSURIContentListener::DoContent(const 
           do_QueryInterface(mDocShell->GetWindow());
         if (contentContext) {
           RefPtr<MaybeCloseWindowHelper> maybeCloseWindowHelper =
             new MaybeCloseWindowHelper(contentContext);
           maybeCloseWindowHelper->SetShouldCloseWindow(true);
           maybeCloseWindowHelper->MaybeCloseWindow();
         }
       }
-      return NS_OK; 
+      return NS_OK;
     }
   }
 
   if (loadFlags & nsIChannel::LOAD_RETARGETED_DOCUMENT_URI) {
     // XXX: Why does this not stop the content too?
     mDocShell->Stop(nsIWebNavigation::STOP_NETWORK);
 
     mDocShell->SetLoadType(aIsContentPreferred ? LOAD_LINK : LOAD_NORMAL);
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -9051,17 +9051,17 @@ nsDocShell::CopyFavicon(nsIURI* aOldURI,
   if (favSvc) {
     favSvc->CopyFavicons(aOldURI, aNewURI,
       aInPrivateBrowsing ? nsIFaviconService::FAVICON_LOAD_PRIVATE
                          : nsIFaviconService::FAVICON_LOAD_NON_PRIVATE, nullptr);
   }
 #endif
 }
 
-struct InternalLoadData 
+struct InternalLoadData
 {
 public:
   InternalLoadData(nsDocShell* aDocShell,
                    nsIURI* aURI,
                    nsIURI* aOriginalURI,
                    Maybe<nsCOMPtr<nsIURI>> const& aResultPrincipalURI,
                    bool aKeepResultPrincipalURIIfSet,
                    bool aLoadReplace,
@@ -9201,17 +9201,17 @@ public:
                 aHeadersData,
                 aLoadType,
                 aSHEntry,
                 aFirstParty,
                 aSrcdoc,
                 aSourceDocShell,
                 aBaseURI,
                 nullptr,
-                nullptr) 
+                nullptr)
   {}
 
   NS_IMETHOD
   Run() override
   {
     return mLoadData.Run();
   }
 
@@ -9300,17 +9300,17 @@ private:
 
   InternalLoadData mLoadData;
 };
 
 NS_IMPL_CYCLE_COLLECTION(LoadURIDelegateHandler, mLoadData.mDocShell,
                          mLoadData.mURI, mLoadData.mOriginalURI,
                          mLoadData.mResultPrincipalURI, mLoadData.mReferrer,
                          mLoadData.mTriggeringPrincipal,
-                         mLoadData.mPrincipalToInherit, 
+                         mLoadData.mPrincipalToInherit,
                          mLoadData.mPostData, mLoadData.mHeadersData,
                          mLoadData.mSHEntry, mLoadData.mSourceDocShell,
                          mLoadData.mBaseURI)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(LoadURIDelegateHandler)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
@@ -9581,17 +9581,17 @@ nsDocShell::InternalLoad(nsIURI* aURI,
     }
 
     RefPtr<dom::Promise> promise;
     rv = mLoadURIDelegate->LoadURI(aURI, where, aFlags, aTriggeringPrincipal,
                                    getter_AddRefs(promise));
     if (NS_SUCCEEDED(rv) && promise) {
       const uint32_t flags = aFlags | INTERNAL_LOAD_FLAGS_DELEGATES_CHECKED;
 
-      RefPtr<LoadURIDelegateHandler> handler = 
+      RefPtr<LoadURIDelegateHandler> handler =
         new LoadURIDelegateHandler(this, aURI, aOriginalURI, aResultPrincipalURI,
                                    aKeepResultPrincipalURIIfSet,
                                    aLoadReplace, aReferrer, aReferrerPolicy,
                                    aTriggeringPrincipal, aPrincipalToInherit,
                                    flags, aWindowTarget, aTypeHint, aFileName, aPostData,
                                    aHeadersData, aLoadType, aSHEntry, aFirstParty,
                                    aSrcdoc, aSourceDocShell, aBaseURI, nullptr, nullptr);
 
--- a/dom/base/CharacterData.cpp
+++ b/dom/base/CharacterData.cpp
@@ -231,17 +231,17 @@ CharacterData::DeleteData(uint32_t aOffs
 void
 CharacterData::ReplaceData(uint32_t aOffset, uint32_t aCount,
                            const nsAString& aData, ErrorResult& aRv)
 {
   nsresult rv = SetTextInternal(aOffset, aCount, aData.BeginReading(),
                                 aData.Length(), true);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
-  }  
+  }
 }
 
 nsresult
 CharacterData::SetTextInternal(uint32_t aOffset, uint32_t aCount,
                                const char16_t* aBuffer,
                                uint32_t aLength, bool aNotify,
                                CharacterDataChangeInfo::Details* aDetails)
 {
--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -1963,17 +1963,17 @@ private:
   /**
    * Get this element's client area rect in app units.
    * @return the frame's client area
    */
   MOZ_CAN_RUN_SCRIPT nsRect GetClientAreaRect();
 
   /**
    * GetCustomInterface is somewhat like a GetInterface, but it is expected
-   * that the implementation is provided by a custom element or via the 
+   * that the implementation is provided by a custom element or via the
    * the XBL implements keyword. To use this, create a public method that
    * wraps a call to GetCustomInterface.
    */
   template<class T> void GetCustomInterface(nsGetterAddRefs<T> aResult);
 
   // Prevent people from doing pointless checks/casts on Element instances.
   void IsElement() = delete;
   void AsElement() = delete;
--- a/dom/base/Link.cpp
+++ b/dom/base/Link.cpp
@@ -267,17 +267,17 @@ Link::UpdatePreload(nsAtom* aName, const
     if (aOldValue) {
       oldPolicyType = AsValueToContentPolicy(*aOldValue);
       if (!HTMLLinkElement::CheckPreloadAttrs(*aOldValue, mimeType, media,
                                               mElement->OwnerDoc())) {
         oldPolicyType = nsIContentPolicy::TYPE_INVALID;
       }
     } else {
       oldPolicyType = nsIContentPolicy::TYPE_INVALID;
-    }    
+    }
   } else if (aName == nsGkAtoms::type) {
     nsAutoString oldType;
     nsAutoString notUsed;
     if (aOldValue) {
       aOldValue->ToString(oldType);
     } else {
       oldType = EmptyString();
     }
--- a/dom/base/Location.cpp
+++ b/dom/base/Location.cpp
@@ -512,17 +512,17 @@ Location::SetHrefWithBase(const nsAStrin
         // <script> tag in the same window.  See bug 178729.
         nsCOMPtr<nsIScriptGlobalObject> ourGlobal =
           docShell ? docShell->GetScriptGlobalObject() : nullptr;
         inScriptTag = (ourGlobal == scriptContext->GetGlobalObject());
       }
     }
 
     return SetURI(newUri, aReplace || inScriptTag);
-  } 
+  }
   return result;
 }
 
 void
 Location::GetOrigin(nsAString& aOrigin,
                     nsIPrincipal& aSubjectPrincipal,
                     ErrorResult& aRv)
 {
--- a/dom/base/nsContentPolicy.h
+++ b/dom/base/nsContentPolicy.h
@@ -30,17 +30,17 @@ class nsContentPolicy : public nsIConten
     nsCategoryCache<nsIContentPolicy> mPolicies;
 
     //Helper type for CheckPolicy
     typedef decltype(&nsIContentPolicy::ShouldProcess) CPMethod;
 
     //Helper method that applies policyMethod across all policies in mPolicies
     // with the given parameters
     nsresult CheckPolicy(CPMethod policyMethod,
-                         nsIURI *aURI, 
+                         nsIURI *aURI,
                          nsILoadInfo *aLoadInfo,
                          const nsACString &mimeGuess,
                          int16_t *decision);
 };
 
 nsresult
 NS_NewContentPolicy(nsIContentPolicy **aResult);
 
--- a/dom/base/nsGlobalWindowOuter.h
+++ b/dom/base/nsGlobalWindowOuter.h
@@ -277,17 +277,17 @@ public:
 
   bool ComputeDefaultWantsUntrusted(mozilla::ErrorResult& aRv) final;
 
   virtual nsPIDOMWindowOuter* GetOwnerGlobalForBindings() override;
 
   virtual nsIGlobalObject* GetOwnerGlobal() const override;
 
   EventTarget* GetTargetForEventTargetChain() override;
-  
+
   using mozilla::dom::EventTarget::DispatchEvent;
   bool DispatchEvent(mozilla::dom::Event& aEvent,
                      mozilla::dom::CallerType aCallerType,
                      mozilla::ErrorResult& aRv) override;
 
   void GetEventTargetParent(mozilla::EventChainPreVisitor& aVisitor) override;
 
   nsresult PostHandleEvent(mozilla::EventChainPostVisitor& aVisitor) override;
--- a/dom/base/nsIGlobalObject.cpp
+++ b/dom/base/nsIGlobalObject.cpp
@@ -221,17 +221,17 @@ nsIGlobalObject::GetOrCreateServiceWorke
   MOZ_DIAGNOSTIC_ASSERT(false, "this global should not have any service worker registrations");
   return nullptr;
 }
 
 nsPIDOMWindowInner*
 nsIGlobalObject::AsInnerWindow()
 {
   if (MOZ_LIKELY(mIsInnerWindow)) {
-    return static_cast<nsPIDOMWindowInner*>(static_cast<nsGlobalWindowInner*>(this)); 
+    return static_cast<nsPIDOMWindowInner*>(static_cast<nsGlobalWindowInner*>(this));
   }
   return nullptr;
 }
 
 size_t
 nsIGlobalObject::ShallowSizeOfExcludingThis(MallocSizeOf aSizeOf) const
 {
   size_t rtn = mHostObjectURIs.ShallowSizeOfExcludingThis(aSizeOf);
--- a/dom/bindings/FakeString.h
+++ b/dom/bindings/FakeString.h
@@ -65,17 +65,17 @@ struct FakeString {
 
   const nsString::char_type* Data() const
   {
     return mData;
   }
 
   nsString::char_type* BeginWriting()
   {
-    MOZ_ASSERT(!(mDataFlags & nsString::DataFlags::REFCOUNTED) || 
+    MOZ_ASSERT(!(mDataFlags & nsString::DataFlags::REFCOUNTED) ||
                !nsStringBuffer::FromData(mData)->IsReadonly());
     return mData;
   }
 
   nsString::size_type Length() const
   {
     return mLength;
   }
--- a/dom/canvas/WebGLContext.cpp
+++ b/dom/canvas/WebGLContext.cpp
@@ -2301,17 +2301,17 @@ WebGLContext::GetUnpackSize(bool isFunc3
 
 
 #if defined(MOZ_WIDGET_ANDROID)
 already_AddRefed<layers::SharedSurfaceTextureClient>
 WebGLContext::GetVRFrame()
 {
     if (!gl)
         return nullptr;
-    
+
     // Create a custom GLScreenBuffer for VR.
     if (!mVRScreen) {
         auto caps = gl->Screen()->mCaps;
         mVRScreen = GLScreenBuffer::Create(gl, gfx::IntSize(1, 1), caps);
 
         RefPtr<ImageBridgeChild> imageBridge = ImageBridgeChild::GetSingleton();
         if (imageBridge) {
             TextureFlags flags = TextureFlags::ORIGIN_BOTTOM_LEFT;
--- a/dom/canvas/WebGLContextDraw.cpp
+++ b/dom/canvas/WebGLContextDraw.cpp
@@ -395,17 +395,17 @@ ValidateDraw(WebGLContext* const webgl, 
 ////////////////////////////////////////
 
 class ScopedFakeVertexAttrib0 final
 {
     WebGLContext* const mWebGL;
     bool mDidFake = false;
 
 public:
-    ScopedFakeVertexAttrib0(WebGLContext* const webgl, 
+    ScopedFakeVertexAttrib0(WebGLContext* const webgl,
                             const uint64_t vertexCount, bool* const out_error)
         : mWebGL(webgl)
     {
         *out_error = false;
 
         if (!mWebGL->DoFakeVertexAttrib0(vertexCount)) {
             *out_error = true;
             return;
--- a/dom/events/ContentEventHandler.cpp
+++ b/dom/events/ContentEventHandler.cpp
@@ -340,17 +340,17 @@ ContentEventHandler::InitCommon(Selectio
   if (NS_WARN_IF(!mSelection)) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   RefPtr<Selection> normalSelection;
   if (mSelection->Type() == SelectionType::eNormal) {
     normalSelection = mSelection;
   } else {
-    normalSelection = 
+    normalSelection =
       selectionController->GetSelection(nsISelectionController::SELECTION_NORMAL);
     if (NS_WARN_IF(!normalSelection)) {
       return NS_ERROR_NOT_AVAILABLE;
     }
   }
 
   rv = InitRootContent(normalSelection);
   if (NS_WARN_IF(NS_FAILED(rv))) {
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -6195,17 +6195,17 @@ EventStateManager::WheelPrefs::HonoursRo
 {
   if (!sInstance) {
     GetInstance(); // initializing sHonoursRootForAutoDir
   }
   return sHonoursRootForAutoDir;
 }
 
 // static
-Maybe<layers::APZWheelAction> 
+Maybe<layers::APZWheelAction>
 EventStateManager::APZWheelActionFor(const WidgetWheelEvent* aEvent)
 {
   if (aEvent->mMessage != eWheel) {
     return Nothing();
   }
   WheelPrefs::Action action =
     WheelPrefs::GetInstance()->ComputeActionFor(aEvent);
   switch (action) {
--- a/dom/events/EventTarget.h
+++ b/dom/events/EventTarget.h
@@ -85,17 +85,17 @@ public:
   nsresult AddEventListener(const nsAString& aType,
                             nsIDOMEventListener* aListener,
                             bool aUseCapture,
                             bool aWantsUntrusted)
   {
     return AddEventListener(aType, aListener, aUseCapture,
                             Nullable<bool>(aWantsUntrusted));
   }
-  
+
   /**
    * This method allows the removal of event listeners represented by
    * nsIDOMEventListener from the event target, with the same semantics as the
    * standard RemoveEventListener.
    */
   void RemoveEventListener(const nsAString& aType,
                            nsIDOMEventListener* aListener,
                            bool aUseCapture);
@@ -235,17 +235,17 @@ public:
    * the mParentTarget is the possible parent object for the event target chain.
    * @see EventDispatcher.h for more documentation about aVisitor.
    *
    * @param aVisitor the visitor object which is used to create the
    *                 event target chain for event dispatching.
    *
    * @note Only EventDispatcher should call this method.
    */
-  virtual void GetEventTargetParent(EventChainPreVisitor& aVisitor) = 0;  
+  virtual void GetEventTargetParent(EventChainPreVisitor& aVisitor) = 0;
 
   /**
    * Called before the capture phase of the event flow and after event target
    * chain creation. This is used to handle things that must be executed before
    * dispatching the event to DOM.
    */
   virtual nsresult PreHandleEvent(EventChainVisitor& aVisitor)
   {
@@ -264,17 +264,17 @@ public:
    * Called after the bubble phase of the system event group.
    * The default handling of the event should happen here.
    * @param aVisitor the visitor object which is used during post handling.
    *
    * @see EventDispatcher.h for documentation about aVisitor.
    * @note Only EventDispatcher should call this method.
    */
   virtual nsresult PostHandleEvent(EventChainPostVisitor& aVisitor) = 0;
-  
+
 protected:
   EventHandlerNonNull* GetEventHandler(nsAtom* aType);
   void SetEventHandler(nsAtom* aType, EventHandlerNonNull* aHandler);
 
   /**
    * Hook for AddEventListener that allows it to compute the right
    * wantsUntrusted boolean when one is not provided.  If this returns failure,
    * the listener will not be added.
--- a/dom/file/uri/BlobURLProtocolHandler.h
+++ b/dom/file/uri/BlobURLProtocolHandler.h
@@ -67,17 +67,17 @@ public:
   static void Traverse(const nsACString& aUri, nsCycleCollectionTraversalCallback& aCallback);
 
   static bool
   GetAllBlobURLEntries(nsTArray<mozilla::dom::BlobURLRegistrationData>& aRegistrations,
                        mozilla::dom::ContentParent* aCP);
 
   // This method returns false if aURI is not a known BlobURL. Otherwise it
   // returns true.
-  // 
+  //
   // When true is returned, the aPrincipal out param is meaningful.  It gets
   // set to the principal that a channel loaded from the blob would get if
   // the blob is not already revoked and to a NullPrincipal if the blob is
   // revoked.
   //
   // This means that for a revoked blob URL this method may either return
   // false or return true and hand out a NullPrincipal in aPrincipal,
   // depending on whether the "remove it from the hashtable" timer has
--- a/dom/html/nsGenericHTMLElement.cpp
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -545,17 +545,17 @@ nsGenericHTMLElement::CheckHandleEventFo
   //link farther up, do nothing.
   nsCOMPtr<nsIContent> target = aVisitor.mPresContext->EventStateManager()->
     GetEventTargetContent(aVisitor.mEvent);
 
   return !target || !target->IsHTMLElement(nsGkAtoms::area) ||
          IsHTMLElement(nsGkAtoms::area);
 }
 
-void 
+void
 nsGenericHTMLElement::GetEventTargetParentForAnchors(EventChainPreVisitor& aVisitor)
 {
   nsGenericHTMLElementBase::GetEventTargetParent(aVisitor);
 
   if (!CheckHandleEventForAnchorsPreconditions(aVisitor)) {
     return;
   }
 
--- a/dom/html/nsHTMLDocument.cpp
+++ b/dom/html/nsHTMLDocument.cpp
@@ -1389,17 +1389,17 @@ nsHTMLDocument::Open(JSContext* cx,
 
   // The open occurred after the document finished loading.
   // So we reset the document and then reinitialize it.
   nsCOMPtr<nsIDocShell> curDocShell = GetDocShell();
   nsCOMPtr<nsIDocShellTreeItem> parent;
   if (curDocShell) {
     curDocShell->GetSameTypeParent(getter_AddRefs(parent));
   }
-  
+
   // We are using the same technique as in nsDocShell to figure
   // out the content policy type. If there is no same type parent,
   // we know we are loading a new top level document.
   nsContentPolicyType policyType;
   if (!parent) {
     policyType = nsIContentPolicy::TYPE_DOCUMENT;
   } else {
     Element* requestingElement = nullptr;
@@ -1978,17 +1978,17 @@ nsHTMLDocument::ResolveName(JSContext* a
     }
 
     // Only one element in the list, return the element instead of returning
     // the list.
     node = list->Item(0);
   } else {
     // No named items were found, see if there's one registerd by id for aName.
     Element *e = entry->GetIdElement();
-  
+
     if (!e || !nsGenericHTMLElement::ShouldExposeIdAsHTMLDocumentProperty(e)) {
       return false;
     }
 
     node = e;
   }
 
   if (!ToJSValue(aCx, node, aRetval)) {
--- a/dom/plugins/ipc/FunctionBroker.h
+++ b/dom/plugins/ipc/FunctionBroker.h
@@ -116,17 +116,17 @@
  *                        int HOOK_CALL (nsDependentCSubstring)> HookedFuncDelegateReq;
  *
  * template<>
  * void HookedFuncFB::Request::Marshal(IpdlTuple& aTuple, const void*& aBuf, const int& aBufLen)
  * {
  *   MOZ_ASSERT(nWritten);
  *   HookedFuncDelegateReq::Marshal(aTuple, nsDependentCSubstring(aBuf, aBufLen));
  * }
- * 
+ *
  * template<>
  * bool HookedFuncFB::Request::Unmarshal(ServerCallData& aScd, const IpdlTuple& aTuple,
  *                                       void*& aBuf, int& aBufLen)
  * {
  *   nsDependentCSubstring str;
  *   if (!HookedFuncDelegateReq::Unmarshal(aScd, aTuple, str)) {
  *     return false;
  *   }
@@ -163,17 +163,17 @@ extern IdToUlongPairMap sIdToPairMap;
 typedef std::map<void*, uint64_t> PtrToIdMap;
 extern PtrToIdMap sPtrToIdMap;
 typedef std::map<uint64_t, void*> IdToPtrMap;
 extern IdToPtrMap sIdToPtrMap;
 
 #else // defined(XP_WIN)
 
 // Any methods we hook use the default calling convention.
-#define HOOK_CALL 
+#define HOOK_CALL
 
 #endif // defined(XP_WIN)
 
 inline bool IsOdd(uint64_t aVal) { return aVal & 1; }
 
 // This enum is used to track if this process is currently running the client
 // or server side of brokering.
 enum Endpoint { SERVER, CLIENT };
--- a/dom/plugins/ipc/FunctionBrokerChild.cpp
+++ b/dom/plugins/ipc/FunctionBrokerChild.cpp
@@ -51,72 +51,72 @@ FunctionBrokerChild::GetInstance()
 
 FunctionBrokerChild::FunctionBrokerChild(FunctionBrokerThread* aThread,
                                          Endpoint<PFunctionBrokerChild>&& aEndpoint) :
     mThread(aThread)
   , mShutdownDone(false)
   , mMonitor("FunctionBrokerChild Lock")
 {
   MOZ_ASSERT(aThread);
-  PostToDispatchThread(NewNonOwningRunnableMethod<Endpoint<PFunctionBrokerChild>&&>(
-                       "FunctionBrokerChild::Bind", this, &FunctionBrokerChild::Bind,
-                       std::move(aEndpoint)));
+  PostToDispatchThread(NewNonOwningRunnableMethod<Endpoint<PFunctionBrokerChild>&&>(
+                       "FunctionBrokerChild::Bind", this, &FunctionBrokerChild::Bind,
+                       std::move(aEndpoint)));
 }
-
-void
-FunctionBrokerChild::Bind(Endpoint<PFunctionBrokerChild>&& aEndpoint)
+
+void
+FunctionBrokerChild::Bind(Endpoint<PFunctionBrokerChild>&& aEndpoint)
 {
-  MOZ_RELEASE_ASSERT(mThread->IsOnThread());
-  DebugOnly<bool> ok = aEndpoint.Bind(this);
-  MOZ_ASSERT(ok);
-}
+  MOZ_RELEASE_ASSERT(mThread->IsOnThread());
+  DebugOnly<bool> ok = aEndpoint.Bind(this);
+  MOZ_ASSERT(ok);
+}
 
 void
 FunctionBrokerChild::ShutdownOnDispatchThread()
 {
   MOZ_ASSERT(mThread->IsOnThread());
 
   // Set mShutdownDone and notify waiting thread (if any) that we are done.
-  MonitorAutoLock lock(mMonitor);
-  mShutdownDone = true;
+  MonitorAutoLock lock(mMonitor);
+  mShutdownDone = true;
   mMonitor.Notify();
 }
 
 void
 FunctionBrokerChild::ActorDestroy(ActorDestroyReason aWhy)
 {
   MOZ_ASSERT(mThread->IsOnThread());
-
-  // Queue up a task on the PD thread.  When that task is executed then
-  // we know that anything queued before ActorDestroy has completed.
-  // At that point, we can set mShutdownDone and alert any waiting
-  // threads that it is safe to destroy us.
-  sInstance->PostToDispatchThread(NewNonOwningRunnableMethod(
-                                  "FunctionBrokerChild::ShutdownOnDispatchThread", sInstance,
-                                  &FunctionBrokerChild::ShutdownOnDispatchThread));
+
+  // Queue up a task on the PD thread.  When that task is executed then
+  // we know that anything queued before ActorDestroy has completed.
+  // At that point, we can set mShutdownDone and alert any waiting
+  // threads that it is safe to destroy us.
+  sInstance->PostToDispatchThread(NewNonOwningRunnableMethod(
+                                  "FunctionBrokerChild::ShutdownOnDispatchThread", sInstance,
+                                  &FunctionBrokerChild::ShutdownOnDispatchThread));
 }
 
 void
 FunctionBrokerChild::Destroy()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sInstance) {
     return;
   }
 
   // mShutdownDone will tell us when ActorDestroy has been run and any tasks
   // on the FunctionBrokerThread have completed.  At that point, we can
   // safely delete the actor.
   {
-    MonitorAutoLock lock(sInstance->mMonitor);
-    while (!sInstance->mShutdownDone) {
-      // Release lock and wait.  Regain lock when we are notified that
-      // we have ShutdownOnDispatchThread.
-      sInstance->mMonitor.Wait();
+    MonitorAutoLock lock(sInstance->mMonitor);
+    while (!sInstance->mShutdownDone) {
+      // Release lock and wait.  Regain lock when we are notified that
+      // we have ShutdownOnDispatchThread.
+      sInstance->mMonitor.Wait();
     }
   }
 
   delete sInstance;
   sInstance = nullptr;
 }
 
 } // namespace plugins
--- a/dom/plugins/ipc/FunctionBrokerIPCUtils.cpp
+++ b/dom/plugins/ipc/FunctionBrokerIPCUtils.cpp
@@ -261,17 +261,17 @@ IPCSchannelCred::CopyTo(PSCHANNEL_CRED& 
 
 void
 IPCInternetBuffers::CopyFrom(const LPINTERNET_BUFFERSA& aBufs)
 {
   mBuffers.Clear();
 
   LPINTERNET_BUFFERSA inetBuf = aBufs;
   while (inetBuf) {
-    MOZ_ASSERT(inetBuf->dwStructSize == sizeof(INTERNET_BUFFERSA));
+    MOZ_ASSERT(inetBuf->dwStructSize == sizeof(INTERNET_BUFFERSA));
     Buffer* ipcBuf = mBuffers.AppendElement();
 
     ipcBuf->mHeader.SetIsVoid(inetBuf->lpcszHeader == nullptr);
     if (inetBuf->lpcszHeader) {
       ipcBuf->mHeader.Assign(inetBuf->lpcszHeader, inetBuf->dwHeadersLength);
     }
     ipcBuf->mHeaderTotal = inetBuf->dwHeadersTotal;
 
--- a/dom/plugins/ipc/FunctionBrokerIPCUtils.h
+++ b/dom/plugins/ipc/FunctionBrokerIPCUtils.h
@@ -3,17 +3,17 @@
 
 #include "PluginMessageUtils.h"
 
 #if defined(XP_WIN)
 
 #define SECURITY_WIN32
 #include <security.h>
 #include <wininet.h>
-#include <schannel.h>
+#include <schannel.h>
 #include <commdlg.h>
 
 #endif // defined(XP_WIN)
 
 namespace mozilla {
 namespace plugins {
 
 /**
@@ -191,20 +191,20 @@ typedef struct _IPCInternetBuffers
   static void FreeBuffers(LPINTERNET_BUFFERSA& aBufs);
 
   struct Buffer
   {
     nsCString mHeader;
     uint32_t mHeaderTotal;
     nsCString mBuffer;
     uint32_t mBufferTotal;
-    bool operator==(const Buffer& o) const
-    {
-      return (o.mHeader == mHeader) && (o.mHeaderTotal == mHeaderTotal) &&
-             (o.mBuffer == mBuffer) && (o.mBufferTotal == mBufferTotal);
+    bool operator==(const Buffer& o) const
+    {
+      return (o.mHeader == mHeader) && (o.mHeaderTotal == mHeaderTotal) &&
+             (o.mBuffer == mBuffer) && (o.mBufferTotal == mBufferTotal);
     }
   };
   nsTArray<Buffer> mBuffers;
 } IPCInternetBuffers;
 
 typedef struct _IPCPrintDlg
 {
   void CopyFrom(const LPPRINTDLGW& aDlg);
@@ -323,21 +323,21 @@ struct ParamTraits<OpenFileNameRetIPC>
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     aLog->append(StringPrintf(L"[%ls, %ls, %ls, %d, %d]", aParam.mCustomFilterOut.c_str(),
                               aParam.mFile.c_str(), aParam.mFileTitle.c_str(),
                               aParam.mFileOffset, aParam.mFileExtension));
   }
 };
 
-template <>
-struct ParamTraits<mozilla::plugins::GetFileNameFunc> :
-  public ContiguousEnumSerializerInclusive<mozilla::plugins::GetFileNameFunc,
-                                           mozilla::plugins::OPEN_FUNC,
-                                           mozilla::plugins::SAVE_FUNC>
+template <>
+struct ParamTraits<mozilla::plugins::GetFileNameFunc> :
+  public ContiguousEnumSerializerInclusive<mozilla::plugins::GetFileNameFunc,
+                                           mozilla::plugins::OPEN_FUNC,
+                                           mozilla::plugins::SAVE_FUNC>
 {};
 
 template <>
 struct ParamTraits<IPCSchannelCred>
 {
   typedef mozilla::plugins::IPCSchannelCred paramType;
 
   static void Write(Message* aMsg, const paramType& aParam)
@@ -367,69 +367,69 @@ struct ParamTraits<IPCSchannelCred>
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     aLog->append(StringPrintf(L"[%d,%d,%d,%d]",
                               aParam.mEnabledProtocols, aParam.mMinStrength,
                               aParam.mMaxStrength, aParam.mFlags));
   }
 };
 
-template <>
-struct ParamTraits<IPCInternetBuffers::Buffer>
-{
-  typedef mozilla::plugins::IPCInternetBuffers::Buffer paramType;
-
-  static void Write(Message* aMsg, const paramType& aParam)
-  {
-    WriteParam(aMsg, aParam.mHeader);
-    WriteParam(aMsg, aParam.mHeaderTotal);
-    WriteParam(aMsg, aParam.mBuffer);
-    WriteParam(aMsg, aParam.mBufferTotal);
-  }
-
-  static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
-  {
-    return ReadParam(aMsg, aIter, &aResult->mHeader) &&
-           ReadParam(aMsg, aIter, &aResult->mHeaderTotal) &&
-           ReadParam(aMsg, aIter, &aResult->mBuffer) &&
-           ReadParam(aMsg, aIter, &aResult->mBufferTotal);
-  }
-
-  static void Log(const paramType& aParam, std::wstring* aLog)
-  {
-    nsCString head = mozilla::plugins::FormatBlob(aParam.mHeader);
-    nsCString buffer = mozilla::plugins::FormatBlob(aParam.mBuffer);
-    std::string msg = StringPrintf("[%s, %d, %s, %d]",
-                                   head.Data(), aParam.mHeaderTotal,
-                                   buffer.Data(), aParam.mBufferTotal);
-    aLog->append(msg.begin(), msg.end());
-  }
-};
-
-template <>
-struct ParamTraits<IPCInternetBuffers>
-{
-  typedef mozilla::plugins::IPCInternetBuffers paramType;
-
-  static void Write(Message* aMsg, const paramType& aParam)
-  {
-    WriteParam(aMsg, aParam.mBuffers);
-  }
-
-  static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
-  {
-    return ReadParam(aMsg, aIter, &aResult->mBuffers);
-  }
-
-  static void Log(const paramType& aParam, std::wstring* aLog)
-  {
-    ParamTraits<nsTArray<IPCInternetBuffers::Buffer>>::Log(aParam.mBuffers, aLog);
-  }
-};
-
+template <>
+struct ParamTraits<IPCInternetBuffers::Buffer>
+{
+  typedef mozilla::plugins::IPCInternetBuffers::Buffer paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam)
+  {
+    WriteParam(aMsg, aParam.mHeader);
+    WriteParam(aMsg, aParam.mHeaderTotal);
+    WriteParam(aMsg, aParam.mBuffer);
+    WriteParam(aMsg, aParam.mBufferTotal);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+  {
+    return ReadParam(aMsg, aIter, &aResult->mHeader) &&
+           ReadParam(aMsg, aIter, &aResult->mHeaderTotal) &&
+           ReadParam(aMsg, aIter, &aResult->mBuffer) &&
+           ReadParam(aMsg, aIter, &aResult->mBufferTotal);
+  }
+
+  static void Log(const paramType& aParam, std::wstring* aLog)
+  {
+    nsCString head = mozilla::plugins::FormatBlob(aParam.mHeader);
+    nsCString buffer = mozilla::plugins::FormatBlob(aParam.mBuffer);
+    std::string msg = StringPrintf("[%s, %d, %s, %d]",
+                                   head.Data(), aParam.mHeaderTotal,
+                                   buffer.Data(), aParam.mBufferTotal);
+    aLog->append(msg.begin(), msg.end());
+  }
+};
+
+template <>
+struct ParamTraits<IPCInternetBuffers>
+{
+  typedef mozilla::plugins::IPCInternetBuffers paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam)
+  {
+    WriteParam(aMsg, aParam.mBuffers);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+  {
+    return ReadParam(aMsg, aIter, &aResult->mBuffers);
+  }
+
+  static void Log(const paramType& aParam, std::wstring* aLog)
+  {
+    ParamTraits<nsTArray<IPCInternetBuffers::Buffer>>::Log(aParam.mBuffers, aLog);
+  }
+};
+
 template <>
 struct ParamTraits<IPCPrintDlg>
 {
   typedef mozilla::plugins::IPCPrintDlg paramType;
 
   static void Write(Message* aMsg, const paramType& aParam)
   {
     MOZ_ASSERT_UNREACHABLE("TODO: DLP:");
--- a/dom/plugins/ipc/FunctionBrokerParent.cpp
+++ b/dom/plugins/ipc/FunctionBrokerParent.cpp
@@ -1,28 +1,28 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: sw=4 ts=4 et :
  * 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 "FunctionBrokerParent.h"
-#include "FunctionBroker.h"
-#include "FunctionBrokerThread.h"
+#include "FunctionBroker.h"
+#include "FunctionBrokerThread.h"
 
 namespace mozilla {
 namespace plugins {
 
-#if defined(XP_WIN)
-UlongPairToIdMap sPairToIdMap;
-IdToUlongPairMap sIdToPairMap;
-PtrToIdMap sPtrToIdMap;
-IdToPtrMap sIdToPtrMap;
-#endif // defined(XP_WIN)
-
+#if defined(XP_WIN)
+UlongPairToIdMap sPairToIdMap;
+IdToUlongPairMap sIdToPairMap;
+PtrToIdMap sPtrToIdMap;
+IdToPtrMap sIdToPtrMap;
+#endif // defined(XP_WIN)
+
 /* static */ FunctionBrokerParent*
 FunctionBrokerParent::Create(Endpoint<PFunctionBrokerParent>&& aParentEnd)
 {
   FunctionBrokerThread* thread = FunctionBrokerThread::Create();
   if (!thread) {
     return nullptr;
   }
 
@@ -35,118 +35,118 @@ FunctionBrokerParent::Create(Endpoint<PF
 
 FunctionBrokerParent::FunctionBrokerParent(FunctionBrokerThread* aThread,
                                            Endpoint<PFunctionBrokerParent>&& aParentEnd) :
     mThread(aThread)
   , mMonitor("FunctionBrokerParent Lock")
   , mShutdownDone(false)
 {
   MOZ_ASSERT(mThread);
-  mThread->Dispatch(NewNonOwningRunnableMethod<Endpoint<PFunctionBrokerParent>&&>(
-          "FunctionBrokerParent::Bind", this, &FunctionBrokerParent::Bind, std::move(aParentEnd)));
-}
-
-FunctionBrokerParent::~FunctionBrokerParent()
-{
-#if defined(XP_WIN) && defined(MOZ_SANDBOX)
-  // Clean up any file permissions that we granted to the child process.
-  MOZ_RELEASE_ASSERT(NS_IsMainThread());
-  RemovePermissionsForProcess(OtherPid());
-#endif
-}
-
-void
-FunctionBrokerParent::Bind(Endpoint<PFunctionBrokerParent>&& aEnd)
-{
-  MOZ_RELEASE_ASSERT(mThread->IsOnThread());
-  DebugOnly<bool> ok = aEnd.Bind(this);
-  MOZ_ASSERT(ok);
-}
+  mThread->Dispatch(NewNonOwningRunnableMethod<Endpoint<PFunctionBrokerParent>&&>(
+          "FunctionBrokerParent::Bind", this, &FunctionBrokerParent::Bind, std::move(aParentEnd)));
+}
+
+FunctionBrokerParent::~FunctionBrokerParent()
+{
+#if defined(XP_WIN) && defined(MOZ_SANDBOX)
+  // Clean up any file permissions that we granted to the child process.
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  RemovePermissionsForProcess(OtherPid());
+#endif
+}
+
+void
+FunctionBrokerParent::Bind(Endpoint<PFunctionBrokerParent>&& aEnd)
+{
+  MOZ_RELEASE_ASSERT(mThread->IsOnThread());
+  DebugOnly<bool> ok = aEnd.Bind(this);
+  MOZ_ASSERT(ok);
+}
 
 void
 FunctionBrokerParent::ShutdownOnBrokerThread()
 {
   MOZ_ASSERT(mThread->IsOnThread());
   Close();
 
   // Notify waiting thread that we are done.
-  MonitorAutoLock lock(mMonitor);
-  mShutdownDone = true;
+  MonitorAutoLock lock(mMonitor);
+  mShutdownDone = true;
   mMonitor.Notify();
 }
 
 void
 FunctionBrokerParent::Destroy(FunctionBrokerParent* aInst)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aInst);
 
   {
     // Hold the lock while we destroy the actor on the broker thread.
-    MonitorAutoLock lock(aInst->mMonitor);
-    aInst->mThread->Dispatch(NewNonOwningRunnableMethod(
-      "FunctionBrokerParent::ShutdownOnBrokerThread", aInst,
-      &FunctionBrokerParent::ShutdownOnBrokerThread));
+    MonitorAutoLock lock(aInst->mMonitor);
+    aInst->mThread->Dispatch(NewNonOwningRunnableMethod(
+      "FunctionBrokerParent::ShutdownOnBrokerThread", aInst,
+      &FunctionBrokerParent::ShutdownOnBrokerThread));
 
     // Wait for broker thread to complete destruction.
-    while (!aInst->mShutdownDone) {
-      aInst->mMonitor.Wait();
+    while (!aInst->mShutdownDone) {
+      aInst->mMonitor.Wait();
     }
   }
 
   delete aInst;
 }
 
 void
 FunctionBrokerParent::ActorDestroy(ActorDestroyReason aWhy)
 {
-  MOZ_RELEASE_ASSERT(mThread->IsOnThread());
+  MOZ_RELEASE_ASSERT(mThread->IsOnThread());
+}
+
+mozilla::ipc::IPCResult
+FunctionBrokerParent::RecvBrokerFunction(const FunctionHookId &aFunctionId,
+                                         const IpdlTuple &aInTuple,
+                                         IpdlTuple *aOutTuple)
+{
+#if defined(XP_WIN)
+  MOZ_ASSERT(mThread->IsOnThread());
+  if (RunBrokeredFunction(OtherPid(), aFunctionId, aInTuple, aOutTuple)) {
+    return IPC_OK();
+  }
+  return IPC_FAIL_NO_REASON(this);
+#else
+  MOZ_ASSERT_UNREACHABLE("BrokerFunction is currently only implemented on Windows.");
+  return IPC_FAIL_NO_REASON(this);
+#endif
 }
 
-mozilla::ipc::IPCResult
-FunctionBrokerParent::RecvBrokerFunction(const FunctionHookId &aFunctionId,
-                                         const IpdlTuple &aInTuple,
-                                         IpdlTuple *aOutTuple)
-{
-#if defined(XP_WIN)
-  MOZ_ASSERT(mThread->IsOnThread());
-  if (RunBrokeredFunction(OtherPid(), aFunctionId, aInTuple, aOutTuple)) {
-    return IPC_OK();
-  }
-  return IPC_FAIL_NO_REASON(this);
-#else
-  MOZ_ASSERT_UNREACHABLE("BrokerFunction is currently only implemented on Windows.");
-  return IPC_FAIL_NO_REASON(this);
-#endif
-}
-
-// static
-bool
-FunctionBrokerParent::RunBrokeredFunction(base::ProcessId aClientId,
-                                        const FunctionHookId &aFunctionId,
-                                        const IPC::IpdlTuple &aInTuple,
-                                        IPC::IpdlTuple *aOutTuple)
-{
-  if ((size_t)aFunctionId >= FunctionHook::GetHooks()->Length()) {
-    MOZ_ASSERT_UNREACHABLE("Invalid function ID");
-    return false;
-  }
-
-  FunctionHook* hook = FunctionHook::GetHooks()->ElementAt(aFunctionId);
-  MOZ_ASSERT(hook->FunctionId() == aFunctionId);
-  return hook->RunOriginalFunction(aClientId, aInTuple, aOutTuple);
-}
-
-#if defined(XP_WIN) && defined(MOZ_SANDBOX)
-
-mozilla::SandboxPermissions FunctionBrokerParent::sSandboxPermissions;
-
-// static
-void
-FunctionBrokerParent::RemovePermissionsForProcess(base::ProcessId aClientId)
-{
-  sSandboxPermissions.RemovePermissionsForProcess(aClientId);
-}
-
-#endif // defined(XP_WIN) && defined(MOZ_SANDBOX)
+// static
+bool
+FunctionBrokerParent::RunBrokeredFunction(base::ProcessId aClientId,
+                                        const FunctionHookId &aFunctionId,
+                                        const IPC::IpdlTuple &aInTuple,
+                                        IPC::IpdlTuple *aOutTuple)
+{
+  if ((size_t)aFunctionId >= FunctionHook::GetHooks()->Length()) {
+    MOZ_ASSERT_UNREACHABLE("Invalid function ID");
+    return false;
+  }
+
+  FunctionHook* hook = FunctionHook::GetHooks()->ElementAt(aFunctionId);
+  MOZ_ASSERT(hook->FunctionId() == aFunctionId);
+  return hook->RunOriginalFunction(aClientId, aInTuple, aOutTuple);
+}
+
+#if defined(XP_WIN) && defined(MOZ_SANDBOX)
+
+mozilla::SandboxPermissions FunctionBrokerParent::sSandboxPermissions;
+
+// static
+void
+FunctionBrokerParent::RemovePermissionsForProcess(base::ProcessId aClientId)
+{
+  sSandboxPermissions.RemovePermissionsForProcess(aClientId);
+}
+
+#endif // defined(XP_WIN) && defined(MOZ_SANDBOX)
 
 } // namespace plugins
 } // namespace mozilla
--- a/dom/plugins/ipc/FunctionBrokerParent.h
+++ b/dom/plugins/ipc/FunctionBrokerParent.h
@@ -3,18 +3,18 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_plugins_functionbrokerparent_h
 #define mozilla_plugins_functionbrokerparent_h
 
 #include "mozilla/plugins/PFunctionBrokerParent.h"
-#if defined(XP_WIN) && defined(MOZ_SANDBOX)
-#include "sandboxPermissions.h"
+#if defined(XP_WIN) && defined(MOZ_SANDBOX)
+#include "sandboxPermissions.h"
 #endif
 
 namespace mozilla {
 namespace plugins {
 
 class FunctionBrokerThread;
 
 /**
@@ -24,42 +24,42 @@ class FunctionBrokerThread;
 class FunctionBrokerParent : public PFunctionBrokerParent
 {
 public:
   static FunctionBrokerParent* Create(Endpoint<PFunctionBrokerParent>&& aParentEnd);
   static void Destroy(FunctionBrokerParent* aInst);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  mozilla::ipc::IPCResult
-  RecvBrokerFunction(const FunctionHookId &aFunctionId, const IpdlTuple &aInTuple,
-                   IpdlTuple *aOutTuple) override;
-
-#if defined(XP_WIN) && defined(MOZ_SANDBOX)
-  static mozilla::SandboxPermissions*
-  GetSandboxPermissions() { return &sSandboxPermissions; }
-#endif // defined(XP_WIN) && defined(MOZ_SANDBOX)
+  mozilla::ipc::IPCResult
+  RecvBrokerFunction(const FunctionHookId &aFunctionId, const IpdlTuple &aInTuple,
+                   IpdlTuple *aOutTuple) override;
+
+#if defined(XP_WIN) && defined(MOZ_SANDBOX)
+  static mozilla::SandboxPermissions*
+  GetSandboxPermissions() { return &sSandboxPermissions; }
+#endif // defined(XP_WIN) && defined(MOZ_SANDBOX)
 
 private:
   explicit FunctionBrokerParent(FunctionBrokerThread* aThread,
                                 Endpoint<PFunctionBrokerParent>&& aParentEnd);
-  ~FunctionBrokerParent();
+  ~FunctionBrokerParent();
   void ShutdownOnBrokerThread();
   void Bind(Endpoint<PFunctionBrokerParent>&& aEnd);
-
-  static bool RunBrokeredFunction(base::ProcessId aClientId,
-                                  const FunctionHookId &aFunctionId,
-                                  const IPC::IpdlTuple &aInTuple,
-                                  IPC::IpdlTuple *aOutTuple);
-
-#if defined(XP_WIN) && defined(MOZ_SANDBOX)
-  static void RemovePermissionsForProcess(base::ProcessId aClientId);
-  static mozilla::SandboxPermissions sSandboxPermissions;
-#endif // defined(XP_WIN) && defined(MOZ_SANDBOX)
-
+
+  static bool RunBrokeredFunction(base::ProcessId aClientId,
+                                  const FunctionHookId &aFunctionId,
+                                  const IPC::IpdlTuple &aInTuple,
+                                  IPC::IpdlTuple *aOutTuple);
+
+#if defined(XP_WIN) && defined(MOZ_SANDBOX)
+  static void RemovePermissionsForProcess(base::ProcessId aClientId);
+  static mozilla::SandboxPermissions sSandboxPermissions;
+#endif // defined(XP_WIN) && defined(MOZ_SANDBOX)
+
   nsAutoPtr<FunctionBrokerThread> mThread;
   Monitor mMonitor;
   bool mShutdownDone;
 };
 
 } // namespace plugins
 } // namespace mozilla
 
--- a/dom/plugins/ipc/FunctionBrokerThread.h
+++ b/dom/plugins/ipc/FunctionBrokerThread.h
@@ -7,51 +7,51 @@
 #ifndef mozilla_plugins_functionbrokerthread_h
 #define mozilla_plugins_functionbrokerthread_h
 
 #include "nsThreadManager.h"
 
 namespace mozilla {
 namespace plugins {
 
-class FunctionBrokerThread
-{
-public:
-  void Dispatch(already_AddRefed<nsIRunnable>&& aRunnable)
-  {
-    mThread->Dispatch(std::move(aRunnable), nsIEventTarget::NS_DISPATCH_NORMAL);
-  }
-
-  bool IsOnThread()
-  {
-    bool on;
-    return NS_SUCCEEDED(mThread->IsOnCurrentThread(&on)) && on;
-  }
-
-  static FunctionBrokerThread* Create()
-  {
-    MOZ_RELEASE_ASSERT(NS_IsMainThread());
-    nsCOMPtr<nsIThread> thread;
-    if (NS_FAILED(NS_NewNamedThread("Function Broker", getter_AddRefs(thread)))) {
-      return nullptr;
-    }
-    return new FunctionBrokerThread(thread);
-  }
-
-  ~FunctionBrokerThread()
-  {
-    MOZ_RELEASE_ASSERT(NS_IsMainThread());
-    mThread->Shutdown();
-  }
-
-private:
-  explicit FunctionBrokerThread(nsIThread* aThread) : mThread(aThread)
-  {
-    MOZ_ASSERT(mThread);
-  }
-
-  nsCOMPtr<nsIThread> mThread;
-};
+class FunctionBrokerThread
+{
+public:
+  void Dispatch(already_AddRefed<nsIRunnable>&& aRunnable)
+  {
+    mThread->Dispatch(std::move(aRunnable), nsIEventTarget::NS_DISPATCH_NORMAL);
+  }
+
+  bool IsOnThread()
+  {
+    bool on;
+    return NS_SUCCEEDED(mThread->IsOnCurrentThread(&on)) && on;
+  }
+
+  static FunctionBrokerThread* Create()
+  {
+    MOZ_RELEASE_ASSERT(NS_IsMainThread());
+    nsCOMPtr<nsIThread> thread;
+    if (NS_FAILED(NS_NewNamedThread("Function Broker", getter_AddRefs(thread)))) {
+      return nullptr;
+    }
+    return new FunctionBrokerThread(thread);
+  }
+
+  ~FunctionBrokerThread()
+  {
+    MOZ_RELEASE_ASSERT(NS_IsMainThread());
+    mThread->Shutdown();
+  }
+
+private:
+  explicit FunctionBrokerThread(nsIThread* aThread) : mThread(aThread)
+  {
+    MOZ_ASSERT(mThread);
+  }
+
+  nsCOMPtr<nsIThread> mThread;
+};
 
 } // namespace plugins
 } // namespace mozilla
 
 #endif // mozilla_plugins_functionbrokerthread_h
--- a/dom/plugins/ipc/IpdlTuple.h
+++ b/dom/plugins/ipc/IpdlTuple.h
@@ -65,19 +65,19 @@ private:
   };
 
 #if defined(XP_WIN)
   typedef MaybeVariant<int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,
                        int64_t,uint64_t,nsCString,bool,OpenFileNameIPC,
                        OpenFileNameRetIPC,NativeWindowHandle,
                        IPCSchannelCred,IPCInternetBuffers,StringArray,
                        IPCPrintDlg> IpdlTupleElement;
-#else
-  typedef MaybeVariant<int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,
-                       int64_t,uint64_t,nsCString,bool> IpdlTupleElement;
+#else
+  typedef MaybeVariant<int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,
+                       int64_t,uint64_t,nsCString,bool> IpdlTupleElement;
 #endif // defined(XP_WIN)
 
   friend struct IPC::ParamTraits<IpdlTuple>;
   friend struct IPC::ParamTraits<IpdlTuple::IpdlTupleElement>;
   friend struct IPC::ParamTraits<IpdlTuple::InvalidType>;
 
   nsTArray<IpdlTupleElement> mTupleElements;
 };
--- a/dom/security/nsContentSecurityManager.cpp
+++ b/dom/security/nsContentSecurityManager.cpp
@@ -62,17 +62,17 @@ nsContentSecurityManager::AllowTopLevelN
     return true;
   }
 
   nsAutoCString spec;
   rv = uri->GetSpec(spec);
   NS_ENSURE_SUCCESS(rv, true);
   nsAutoCString contentType;
   bool base64;
-  rv = nsDataHandler::ParseURI(spec, contentType, nullptr, 
+  rv = nsDataHandler::ParseURI(spec, contentType, nullptr,
                                base64, nullptr);
   NS_ENSURE_SUCCESS(rv, true);
 
   // Whitelist data: images as long as they are not SVGs
   if (StringBeginsWith(contentType, NS_LITERAL_CSTRING("image/")) &&
       !contentType.EqualsLiteral("image/svg+xml")) {
     return true;
   }
--- a/dom/smil/nsSMILKeySpline.h
+++ b/dom/smil/nsSMILKeySpline.h
@@ -16,17 +16,17 @@
 class nsSMILKeySpline
 {
 public:
   nsSMILKeySpline()
     : mX1(0)
     , mY1(0)
     , mX2(0)
     , mY2(0)
-  { 
+  {
     /* caller must call Init later */\
   }
 
   /**
    * Creates a new key spline control point description.
    *
    * aX1, etc. are the x1, y1, x2, y2 cubic Bezier control points as defined by
    * SMILANIM 3.2.3. They must each be in the range 0.0 <= x <= 1.0
--- a/dom/xml/nsXMLContentSink.h
+++ b/dom/xml/nsXMLContentSink.h
@@ -208,17 +208,17 @@ protected:
 
   nsTArray<StackNode>              mContentStack;
 
   nsCOMPtr<nsIDocumentTransformer> mXSLTProcessor;
 
   // Holds the children in the prolog until the root element is added, after which they're
   // inserted in the document. However, if we're doing an XSLT transform this will
   // actually hold all the children of the source document, until the transform is
-  // finished. After the transform is finished we'll just discard the children. 
+  // finished. After the transform is finished we'll just discard the children.
   nsTArray<nsCOMPtr<nsIContent>> mDocumentChildren;
 
   static const int NS_ACCUMULATION_BUFFER_SIZE = 4096;
   // Our currently accumulated text that we have not flushed to a textnode yet.
   char16_t mText[NS_ACCUMULATION_BUFFER_SIZE];
 };
 
 #endif // nsXMLContentSink_h__
--- a/hal/android/AndroidHal.cpp
+++ b/hal/android/AndroidHal.cpp
@@ -126,17 +126,17 @@ GetCurrentScreenConfiguration(ScreenConf
   int32_t colorDepth, pixelDepth;
   int16_t angle;
   ScreenOrientation orientation;
   nsCOMPtr<nsIScreen> screen;
 
   int32_t rectX, rectY, rectWidth, rectHeight;
 
   screenMgr->GetPrimaryScreen(getter_AddRefs(screen));
-  
+
   screen->GetRect(&rectX, &rectY, &rectWidth, &rectHeight);
   screen->GetColorDepth(&colorDepth);
   screen->GetPixelDepth(&pixelDepth);
   orientation = static_cast<ScreenOrientation>(bridge->GetScreenOrientation());
   angle = bridge->GetScreenAngle();
 
   *aScreenConfiguration =
     hal::ScreenConfiguration(nsIntRect(rectX, rectY, rectWidth, rectHeight),
--- a/image/decoders/nsICODecoder.cpp
+++ b/image/decoders/nsICODecoder.cpp
@@ -625,17 +625,17 @@ nsICODecoder::FinishMask()
     MOZ_ASSERT(mMaskBuffer);
     MOZ_ASSERT(bmpDecoder->GetImageDataLength() > 0);
     for (size_t i = 3 ; i < bmpDecoder->GetImageDataLength() ; i += 4) {
       imageData[i] = mMaskBuffer[i];
     }
     int32_t stride = mDownscaler->TargetSize().width * sizeof(uint32_t);
     DebugOnly<bool> ret =
     // We know the format is B8G8R8A8 because we always assume bmp's inside
-    // ico's are transparent. 
+    // ico's are transparent.
       PremultiplyData(imageData, stride, SurfaceFormat::B8G8R8A8,
         imageData, stride, SurfaceFormat::B8G8R8A8, mDownscaler->TargetSize());
     MOZ_ASSERT(ret);
   }
 
   return Transition::To(ICOState::FINISHED_RESOURCE, 0);
 }
 
--- a/intl/locale/DateTimeFormat.h
+++ b/intl/locale/DateTimeFormat.h
@@ -25,18 +25,18 @@ enum nsDateFormatSelector : long
   kDateFormatWeekday,             // week day (e.g. Mon, Tue)
   kDateFormatYearMonthLong,       // long version of kDateFormatYearMonth
   kDateFormatMonthLong            // long format of month name only
 };
 
 enum nsTimeFormatSelector : long
 {
   kTimeFormatNone = 0,            // don't include the time in the format string
-  kTimeFormatSeconds,             // provides the time format with seconds in the  given locale 
-  kTimeFormatNoSeconds            // provides the time format without seconds in the given locale 
+  kTimeFormatSeconds,             // provides the time format with seconds in the  given locale
+  kTimeFormatNoSeconds            // provides the time format without seconds in the given locale
 };
 
 class DateTimeFormat {
 public:
   // performs a locale sensitive date formatting operation on the PRTime parameter
   static nsresult FormatPRTime(const nsDateFormatSelector aDateFormatSelector,
                                const nsTimeFormatSelector aTimeFormatSelector,
                                const PRTime aPrTime,
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -6153,17 +6153,17 @@ nsLayoutUtils::PaintTextShadow(const nsI
 
     gfxContext* shadowContext = contextBoxBlur.Init(shadowRect, 0, blurRadius,
                                                     presCtx->AppUnitsPerDevPixel(),
                                                     aDestCtx, aDirtyRect, nullptr,
                                                     nsContextBoxBlur::DISABLE_HARDWARE_ACCELERATION_BLUR);
     if (!shadowContext)
       continue;
 
-    
+
 
     aDestCtx->Save();
     aDestCtx->NewPath();
     aDestCtx->SetColor(Color::FromABGR(shadowColor));
 
     // The callback will draw whatever we want to blur as a shadow.
     aCallback(shadowContext, shadowOffset, shadowColor, aCallbackData);
 
--- a/layout/generic/nsQueryFrame.h
+++ b/layout/generic/nsQueryFrame.h
@@ -116,17 +116,17 @@ public:
 
 private:
   // For non-nsIFrame types there is no fast-path.
   template<class Src, class Dst, typename = void, typename = void>
   struct FastQueryFrame
   {
     static Dst* QueryFrame(Src* aFrame) { return nullptr; }
   };
-  
+
   // Specialization for any nsIFrame type to any nsIFrame type -- if the source
   // instance's mClass matches kFrameIID of the destination type then
   // downcasting is safe.
   template<class Src, class Dst>
   struct FastQueryFrame<Src, Dst,
     typename mozilla::EnableIf<mozilla::IsBaseOf<nsIFrame, Src>::value>::Type,
     typename mozilla::EnableIf<mozilla::IsBaseOf<nsIFrame, Dst>::value>::Type>
   {
--- a/layout/style/ServoCSSRuleList.cpp
+++ b/layout/style/ServoCSSRuleList.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* representation of CSSRuleList for stylo */
 
 #include "mozilla/ServoCSSRuleList.h"
 
 #include "mozilla/dom/CSSCounterStyleRule.h"
 #include "mozilla/dom/CSSFontFaceRule.h"
-#include "mozilla/dom/CSSFontFeatureValuesRule.h" 
+#include "mozilla/dom/CSSFontFeatureValuesRule.h"
 #include "mozilla/dom/CSSImportRule.h"
 #include "mozilla/dom/CSSKeyframesRule.h"
 #include "mozilla/dom/CSSMediaRule.h"
 #include "mozilla/dom/CSSMozDocumentRule.h"
 #include "mozilla/dom/CSSNamespaceRule.h"
 #include "mozilla/dom/CSSPageRule.h"
 #include "mozilla/dom/CSSStyleRule.h"
 #include "mozilla/dom/CSSSupportsRule.h"
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -238,17 +238,17 @@ nsTableCellFrame::DidSetComputedStyle(Co
   nsTableFrame* tableFrame = GetTableFrame();
   if (tableFrame->IsBorderCollapse() &&
       tableFrame->BCRecalcNeeded(aOldComputedStyle, Style())) {
     uint32_t colIndex = ColIndex();
     uint32_t rowIndex = RowIndex();
     // row span needs to be clamped as we do not create rows in the cellmap
     // which do not have cells originating in them
     TableArea damageArea(colIndex, rowIndex, GetColSpan(),
-      std::min(static_cast<uint32_t>(GetRowSpan()), 
+      std::min(static_cast<uint32_t>(GetRowSpan()),
                tableFrame->GetRowCount() - rowIndex));
     tableFrame->AddBCDamageArea(damageArea);
   }
 }
 
 #ifdef DEBUG
 void
 nsTableCellFrame::AppendFrames(ChildListID     aListID,
--- a/layout/tables/nsTableCellFrame.h
+++ b/layout/tables/nsTableCellFrame.h
@@ -187,17 +187,17 @@ public:
     // NOTE: We copy this from previous continuations, and we don't ever have
     // dynamic updates when tables split, so our mColIndex always matches our
     // first continuation's.
     MOZ_ASSERT(static_cast<nsTableCellFrame*>(FirstContinuation())->mColIndex ==
                mColIndex,
                "mColIndex out of sync with first continuation");
     return mColIndex;
   }
-    
+
   void SetColIndex(int32_t aColIndex);
 
   /** return the available isize given to this frame during its last reflow */
   inline nscoord GetPriorAvailISize();
 
   /** set the available isize given to this frame during its last reflow */
   inline void SetPriorAvailISize(nscoord aPriorAvailISize);
 
--- a/layout/xul/nsTextBoxFrame.cpp
+++ b/layout/xul/nsTextBoxFrame.cpp
@@ -371,17 +371,17 @@ nsDisplayXULTextBox::CreateWebRenderComm
     return true;
   }
 
 
   auto appUnitsPerDevPixel = Frame()->PresContext()->AppUnitsPerDevPixel();
   gfx::Point deviceOffset = LayoutDevicePoint::FromAppUnits(
       bounds.TopLeft(), appUnitsPerDevPixel).ToUnknownPoint();
 
-  RefPtr<mozilla::layout::TextDrawTarget> textDrawer = 
+  RefPtr<mozilla::layout::TextDrawTarget> textDrawer =
       new mozilla::layout::TextDrawTarget(aBuilder, aResources, aSc, aManager, this, bounds);
   RefPtr<gfxContext> captureCtx = gfxContext::CreateOrNull(textDrawer, deviceOffset);
 
   Paint(aDisplayListBuilder, captureCtx);
   textDrawer->TerminateShadows();
 
   return !textDrawer->HasUnsupportedFeatures();
 }
--- a/layout/xul/tree/TreeBoxObject.cpp
+++ b/layout/xul/tree/TreeBoxObject.cpp
@@ -335,17 +335,17 @@ TreeBoxObject::EnsureCellIsVisible(int32
 
 void
 TreeBoxObject::ScrollToRow(int32_t aRow)
 {
   nsTreeBodyFrame* body = GetTreeBodyFrame(true);
   if (!body) {
     return;
   }
-    
+
   body->ScrollToRow(aRow);
 }
 
 void
 TreeBoxObject::ScrollByLines(int32_t aNumLines)
 {
   nsTreeBodyFrame* body = GetTreeBodyFrame();
   if (!body) {
--- a/layout/xul/tree/nsTreeColumns.cpp
+++ b/layout/xul/tree/nsTreeColumns.cpp
@@ -261,17 +261,17 @@ nsTreeColumn::Element()
 int32_t
 nsTreeColumn::GetX(mozilla::ErrorResult& aRv)
 {
   nsIFrame* frame = GetFrame();
   if (NS_WARN_IF(!frame)) {
     aRv.Throw(NS_ERROR_FAILURE);
     return 0;
   }
-  
+
   return nsPresContext::AppUnitsToIntCSSPixels(frame->GetRect().x);
 }
 
 int32_t
 nsTreeColumn::GetWidth(mozilla::ErrorResult& aRv)
 {
   nsIFrame* frame = GetFrame();
   if (NS_WARN_IF(!frame)) {
--- a/modules/libmar/sign/mar_sign.c
+++ b/modules/libmar/sign/mar_sign.c
@@ -21,47 +21,47 @@
 #include <unistd.h>
 #endif
 
 #include "nss_secutil.h"
 #include "base64.h"
 
 /**
  * Initializes the NSS context.
- * 
+ *
  * @param NSSConfigDir The config dir containing the private key to use
  * @return 0 on success
  *         -1 on error
 */
 int
 NSSInitCryptoContext(const char *NSSConfigDir)
 {
-  SECStatus status = NSS_Initialize(NSSConfigDir, 
+  SECStatus status = NSS_Initialize(NSSConfigDir,
                                     "", "", SECMOD_DB, NSS_INIT_READONLY);
   if (SECSuccess != status) {
     fprintf(stderr, "ERROR: Could not initialize NSS\n");
     return -1;
   }
 
   return 0;
 }
 
-/** 
+/**
  * Obtains a signing context.
  *
  * @param  ctx A pointer to the signing context to fill
  * @return 0 on success
  *         -1 on error
 */
 int
-NSSSignBegin(const char *certName, 
-             SGNContext **ctx, 
-             SECKEYPrivateKey **privKey, 
+NSSSignBegin(const char *certName,
+             SGNContext **ctx,
+             SECKEYPrivateKey **privKey,
              CERTCertificate **cert,
-             uint32_t *signatureLength) 
+             uint32_t *signatureLength)
 {
   secuPWData pwdata = { PW_NONE, 0 };
   if (!certName || !ctx || !privKey || !cert || !signatureLength) {
     fprintf(stderr, "ERROR: Invalid parameter passed to NSSSignBegin\n");
     return -1;
   }
 
   /* Get the cert and embedded public key out of the database */
@@ -76,41 +76,41 @@ NSSSignBegin(const char *certName,
   if (!*privKey) {
     fprintf(stderr, "ERROR: Could not find private key\n");
     return -1;
   }
 
   *signatureLength = PK11_SignatureLen(*privKey);
 
   if (*signatureLength > BLOCKSIZE) {
-    fprintf(stderr, 
+    fprintf(stderr,
             "ERROR: Program must be compiled with a larger block size"
-            " to support signing with signatures this large: %u.\n", 
+            " to support signing with signatures this large: %u.\n",
             *signatureLength);
     return -1;
   }
 
   /* Check that the key length is large enough for our requirements */
   if (*signatureLength < XP_MIN_SIGNATURE_LEN_IN_BYTES) {
-    fprintf(stderr, "ERROR: Key length must be >= %d bytes\n", 
+    fprintf(stderr, "ERROR: Key length must be >= %d bytes\n",
             XP_MIN_SIGNATURE_LEN_IN_BYTES);
     return -1;
   }
 
   *ctx = SGN_NewContext(SEC_OID_PKCS1_SHA384_WITH_RSA_ENCRYPTION, *privKey);
   if (!*ctx) {
     fprintf(stderr, "ERROR: Could not create signature context\n");
     return -1;
   }
-  
+
   if (SGN_Begin(*ctx) != SECSuccess) {
     fprintf(stderr, "ERROR: Could not begin signature\n");
     return -1;
   }
-  
+
   return 0;
 }
 
 /**
  * Writes the passed buffer to the file fp and updates the signature contexts.
  *
  * @param  fpDest   The file pointer to write to.
  * @param  buffer   The buffer to write.
@@ -125,17 +125,17 @@ NSSSignBegin(const char *certName,
 */
 int
 WriteAndUpdateSignatures(FILE *fpDest, void *buffer,
                          uint32_t size, SGNContext **ctxs,
                          uint32_t ctxCount,
                          const char *err)
 {
   uint32_t k;
-  if (!size) { 
+  if (!size) {
     return 0;
   }
 
   if (fwrite(buffer, size, 1, fpDest) != 1) {
     fprintf(stderr, "ERROR: Could not write %s\n", err);
     return -2;
   }
 
@@ -143,34 +143,34 @@ WriteAndUpdateSignatures(FILE *fpDest, v
     if (SGN_Update(ctxs[k], buffer, size) != SECSuccess) {
       fprintf(stderr, "ERROR: Could not update signature context for %s\n", err);
       return -3;
     }
   }
   return 0;
 }
 
-/** 
- * Adjusts each entry's content offset in the the passed in index by the 
+/**
+ * Adjusts each entry's content offset in the the passed in index by the
  * specified amount.
  *
  * @param indexBuf     A buffer containing the MAR index
  * @param indexLength  The length of the MAR index
  * @param offsetAmount The amount to adjust each index entry by
 */
 void
-AdjustIndexContentOffsets(char *indexBuf, uint32_t indexLength, uint32_t offsetAmount) 
+AdjustIndexContentOffsets(char *indexBuf, uint32_t indexLength, uint32_t offsetAmount)
 {
   uint32_t *offsetToContent;
   char *indexBufLoc = indexBuf;
 
   /* Consume the index and adjust each index by the specified amount */
   while (indexBufLoc != (indexBuf + indexLength)) {
     /* Adjust the offset */
-    offsetToContent = (uint32_t *)indexBufLoc; 
+    offsetToContent = (uint32_t *)indexBufLoc;
     *offsetToContent = ntohl(*offsetToContent);
     *offsetToContent += offsetAmount;
     *offsetToContent = htonl(*offsetToContent);
     /* Skip past the offset, length, and flags */
     indexBufLoc += 3 * sizeof(uint32_t);
     indexBufLoc += strlen(indexBufLoc) + 1;
   }
 }
@@ -192,17 +192,17 @@ AdjustIndexContentOffsets(char *indexBuf
  *         -3 on signature update error
 */
 int
 ReadWriteAndUpdateSignatures(FILE *fpSrc, FILE *fpDest, void *buffer,
                              uint32_t size, SGNContext **ctxs,
                              uint32_t ctxCount,
                              const char *err)
 {
-  if (!size) { 
+  if (!size) {
     return 0;
   }
 
   if (fread(buffer, size, 1, fpSrc) != 1) {
     fprintf(stderr, "ERROR: Could not read %s\n", err);
     return -1;
   }
 
@@ -218,20 +218,20 @@ ReadWriteAndUpdateSignatures(FILE *fpSrc
  * @param  buffer The buffer to write.
  * @param  size   The size of the buffer to write.
  * @param  err    The name of what is being written to in case of error.
  * @return  0 on success
  *         -1 on read error
  *         -2 on write error
 */
 int
-ReadAndWrite(FILE *fpSrc, FILE *fpDest, void *buffer, 
-             uint32_t size, const char *err) 
+ReadAndWrite(FILE *fpSrc, FILE *fpDest, void *buffer,
+             uint32_t size, const char *err)
 {
-  if (!size) { 
+  if (!size) {
     return 0;
   }
 
   if (fread(buffer, size, 1, fpSrc) != 1) {
     fprintf(stderr, "ERROR: Could not read %s\n", err);
     return -1;
   }
 
@@ -242,25 +242,25 @@ ReadAndWrite(FILE *fpSrc, FILE *fpDest, 
 
   return 0;
 }
 
 /**
  * Writes out a copy of the MAR at src but with the signature block stripped.
  *
  * @param  src  The path of the source MAR file
- * @param  dest The path of the MAR file to write out that 
+ * @param  dest The path of the MAR file to write out that
                 has no signature block
  * @return 0 on success
  *         -1 on error
 */
 int
 strip_signature_block(const char *src, const char * dest)
 {
-  uint32_t offsetToIndex, dstOffsetToIndex, indexLength, 
+  uint32_t offsetToIndex, dstOffsetToIndex, indexLength,
     numSignatures = 0, leftOver;
   int32_t stripAmount = 0;
   int64_t oldPos, sizeOfEntireMAR = 0, realSizeOfSrcMAR, numBytesToCopy,
     numChunks, i;
   FILE *fpSrc = NULL, *fpDest = NULL;
   int rv = -1, hasSignatureBlock;
   char buf[BLOCKSIZE];
   char *indexBuf = NULL;
@@ -309,27 +309,27 @@ strip_signature_block(const char *src, c
   realSizeOfSrcMAR = ftello(fpSrc);
   if (fseeko(fpSrc, oldPos, SEEK_SET)) {
     fprintf(stderr, "ERROR: Could not seek back to current location.\n");
     goto failure;
   }
 
   if (hasSignatureBlock) {
     /* Get the MAR length and adjust its size */
-    if (fread(&sizeOfEntireMAR, 
+    if (fread(&sizeOfEntireMAR,
               sizeof(sizeOfEntireMAR), 1, fpSrc) != 1) {
       fprintf(stderr, "ERROR: Could read mar size\n");
       goto failure;
     }
     sizeOfEntireMAR = NETWORK_TO_HOST64(sizeOfEntireMAR);
     if (sizeOfEntireMAR != realSizeOfSrcMAR) {
       fprintf(stderr, "ERROR: Source MAR is not of the right size\n");
       goto failure;
     }
-  
+
     /* Get the num signatures in the source file so we know what to strip */
     if (fread(&numSignatures, sizeof(numSignatures), 1, fpSrc) != 1) {
       fprintf(stderr, "ERROR: Could read num signatures\n");
       goto failure;
     }
     numSignatures = ntohl(numSignatures);
 
     for (i = 0; i < numSignatures; i++) {
@@ -347,17 +347,17 @@ strip_signature_block(const char *src, c
       }
       signatureLen = ntohl(signatureLen);
 
       /* Skip past the signature */
       if (fseeko(fpSrc, signatureLen, SEEK_CUR)) {
         fprintf(stderr, "ERROR: Could not skip past signature algorithm ID\n");
       }
 
-      stripAmount += sizeof(uint32_t) + sizeof(uint32_t) + signatureLen; 
+      stripAmount += sizeof(uint32_t) + sizeof(uint32_t) + signatureLen;
     }
 
   } else {
     sizeOfEntireMAR = realSizeOfSrcMAR;
     numSignatures = 0;
   }
 
   if (((int64_t)offsetToIndex) > sizeOfEntireMAR) {
@@ -414,65 +414,65 @@ strip_signature_block(const char *src, c
   /* Read each file and write it to the MAR file */
   for (i = 0; i < numChunks; ++i) {
     if (ReadAndWrite(fpSrc, fpDest, buf, BLOCKSIZE, "content block")) {
       goto failure;
     }
   }
 
   /* Write out the left over */
-  if (ReadAndWrite(fpSrc, fpDest, buf, 
+  if (ReadAndWrite(fpSrc, fpDest, buf,
                    leftOver, "left over content block")) {
     goto failure;
   }
 
   /* Length of the index */
-  if (ReadAndWrite(fpSrc, fpDest, &indexLength, 
+  if (ReadAndWrite(fpSrc, fpDest, &indexLength,
                    sizeof(indexLength), "index length")) {
     goto failure;
   }
   indexLength = ntohl(indexLength);
 
   /* Consume the index and adjust each index by the difference */
   indexBuf = malloc(indexLength);
   if (fread(indexBuf, indexLength, 1, fpSrc) != 1) {
     fprintf(stderr, "ERROR: Could not read index\n");
     goto failure;
   }
 
   /* Adjust each entry in the index */
   if (hasSignatureBlock) {
     AdjustIndexContentOffsets(indexBuf, indexLength, -stripAmount);
   } else {
-    AdjustIndexContentOffsets(indexBuf, indexLength, 
-                              sizeof(sizeOfEntireMAR) + 
-                              sizeof(numSignatures) - 
+    AdjustIndexContentOffsets(indexBuf, indexLength,
+                              sizeof(sizeOfEntireMAR) +
+                              sizeof(numSignatures) -
                               stripAmount);
   }
 
   if (fwrite(indexBuf, indexLength, 1, fpDest) != 1) {
     fprintf(stderr, "ERROR: Could not write index\n");
     goto failure;
   }
 
   rv = 0;
-failure: 
+failure:
   if (fpSrc) {
     fclose(fpSrc);
   }
 
   if (fpDest) {
     fclose(fpDest);
   }
 
   if (rv) {
     remove(dest);
   }
 
-  if (indexBuf) { 
+  if (indexBuf) {
     free(indexBuf);
   }
 
   if (rv) {
     remove(dest);
   }
   return rv;
 }
@@ -798,41 +798,41 @@ failure:
     PORT_Free(passedInSignatureRaw);
   }
 
   return rv;
 }
 
 /**
  * Writes out a copy of the MAR at src but with embedded signatures.
- * The passed in MAR file must not already be signed or an error will 
+ * The passed in MAR file must not already be signed or an error will
  * be returned.
  *
  * @param  NSSConfigDir  The NSS directory containing the private key for signing
  * @param  certNames     The nicknames of the certificate to use for signing
  * @param  certCount     The number of certificate names contained in certNames.
  *                       One signature will be produced for each certificate.
  * @param  src           The path of the source MAR file to sign
  * @param  dest          The path of the MAR file to write out that is signed
  * @return 0 on success
  *         -1 on error
 */
 int
-mar_repackage_and_sign(const char *NSSConfigDir, 
+mar_repackage_and_sign(const char *NSSConfigDir,
                        const char * const *certNames,
                        uint32_t certCount,
-                       const char *src, 
-                       const char *dest) 
+                       const char *src,
+                       const char *dest)
 {
-  uint32_t offsetToIndex, dstOffsetToIndex, indexLength, 
+  uint32_t offsetToIndex, dstOffsetToIndex, indexLength,
     numSignatures = 0, leftOver,
     signatureAlgorithmID, signatureSectionLength = 0;
   uint32_t signatureLengths[MAX_SIGNATURES];
-  int64_t oldPos, sizeOfEntireMAR = 0, realSizeOfSrcMAR, 
-    signaturePlaceholderOffset, numBytesToCopy, 
+  int64_t oldPos, sizeOfEntireMAR = 0, realSizeOfSrcMAR,
+    signaturePlaceholderOffset, numBytesToCopy,
     numChunks, i;
   FILE *fpSrc = NULL, *fpDest = NULL;
   int rv = -1, hasSignatureBlock;
   SGNContext *ctxs[MAX_SIGNATURES];
   SECItem secItems[MAX_SIGNATURES];
   char buf[BLOCKSIZE];
   SECKEYPrivateKey *privKeys[MAX_SIGNATURES];
   CERTCertificate *certs[MAX_SIGNATURES];
@@ -906,27 +906,27 @@ mar_repackage_and_sign(const char *NSSCo
   realSizeOfSrcMAR = ftello(fpSrc);
   if (fseeko(fpSrc, oldPos, SEEK_SET)) {
     fprintf(stderr, "ERROR: Could not seek back to current location.\n");
     goto failure;
   }
 
   if (hasSignatureBlock) {
     /* Get the MAR length and adjust its size */
-    if (fread(&sizeOfEntireMAR, 
+    if (fread(&sizeOfEntireMAR,
               sizeof(sizeOfEntireMAR), 1, fpSrc) != 1) {
       fprintf(stderr, "ERROR: Could read mar size\n");
       goto failure;
     }
     sizeOfEntireMAR = NETWORK_TO_HOST64(sizeOfEntireMAR);
     if (sizeOfEntireMAR != realSizeOfSrcMAR) {
       fprintf(stderr, "ERROR: Source MAR is not of the right size\n");
       goto failure;
     }
-  
+
     /* Get the num signatures in the source file */
     if (fread(&numSignatures, sizeof(numSignatures), 1, fpSrc) != 1) {
       fprintf(stderr, "ERROR: Could read num signatures\n");
       goto failure;
     }
     numSignatures = ntohl(numSignatures);
 
     /* We do not support resigning, if you have multiple signatures,
@@ -1062,19 +1062,19 @@ mar_repackage_and_sign(const char *NSSCo
     fprintf(stderr, "ERROR: Could not read index\n");
     goto failure;
   }
 
   /* Adjust each entry in the index */
   if (hasSignatureBlock) {
     AdjustIndexContentOffsets(indexBuf, indexLength, signatureSectionLength);
   } else {
-    AdjustIndexContentOffsets(indexBuf, indexLength, 
-                              sizeof(sizeOfEntireMAR) + 
-                              sizeof(numSignatures) + 
+    AdjustIndexContentOffsets(indexBuf, indexLength,
+                              sizeof(sizeOfEntireMAR) +
+                              sizeof(numSignatures) +
                               signatureSectionLength);
   }
 
   if (WriteAndUpdateSignatures(fpDest, indexBuf,
                                indexLength, ctxs, certCount, "index")) {
     goto failure;
   }
 
@@ -1114,30 +1114,30 @@ mar_repackage_and_sign(const char *NSSCo
       *** THIS IS NOT SIGNED because it is the signature itself. *** */
     if (fwrite(secItems[k].data, secItems[k].len, 1, fpDest) != 1) {
       fprintf(stderr, "ERROR: Could not write signature\n");
       goto failure;
     }
   }
 
   rv = 0;
-failure: 
+failure:
   if (fpSrc) {
     fclose(fpSrc);
   }
 
   if (fpDest) {
     fclose(fpDest);
   }
 
   if (rv) {
     remove(dest);
   }
 
-  if (indexBuf) { 
+  if (indexBuf) {
     free(indexBuf);
   }
 
   /* Cleanup */
   for (k = 0; k < certCount; k++) {
     if (ctxs[k]) {
       SGN_DestroyContext(ctxs[k], PR_TRUE);
     }
--- a/modules/libmar/sign/nss_secutil.c
+++ b/modules/libmar/sign/nss_secutil.c
@@ -69,17 +69,17 @@ GetPasswordString(void *arg, char *promp
     };
 
     input = fopen(consoleName, "r");
     if (input == NULL) {
       fprintf(stderr, "Error opening input terminal for read\n");
       return NULL;
     }
   }
-#endif 
+#endif
 
   if (isInputTerminal) {
     fprintf(stdout, "Please enter your password:\n");
     fflush(stdout);
   }
 
   if (!QUIET_FGETS(phrase, sizeof(phrase), input)) {
     fprintf(stderr, "QUIET_FGETS failed\n");
@@ -92,17 +92,17 @@ GetPasswordString(void *arg, char *promp
 
 #ifndef _WINDOWS
   if (isInputTerminal) {
     fclose(input);
   }
 #endif
 
   /* Strip off the newlines if present */
-  if (phrase[PORT_Strlen(phrase)-1] == '\n' || 
+  if (phrase[PORT_Strlen(phrase)-1] == '\n' ||
       phrase[PORT_Strlen(phrase)-1] == '\r') {
     phrase[PORT_Strlen(phrase)-1] = 0;
   }
   return (char*) PORT_Strdup(phrase);
 }
 
 char *
 SECU_FilePasswd(PK11SlotInfo *slot, PRBool retry, void *arg)
@@ -180,17 +180,17 @@ SECU_FilePasswd(PK11SlotInfo *slot, PRBo
   } while (i<nb);
 
   phrase = PORT_Strdup((char*)phrase);
   PORT_Free(phrases);
   return phrase;
 }
 
 char *
-SECU_GetModulePassword(PK11SlotInfo *slot, PRBool retry, void *arg) 
+SECU_GetModulePassword(PK11SlotInfo *slot, PRBool retry, void *arg)
 {
     char prompt[255];
     secuPWData *pwdata = (secuPWData *)arg;
     secuPWData pwnull = { PW_NONE, 0 };
     secuPWData pwxtrn = { PW_EXTERNAL, "external" };
     char *pw;
 
     if (pwdata == NULL)
@@ -214,17 +214,17 @@ SECU_GetModulePassword(PK11SlotInfo *slo
    * once, then keep it in memory (duh).
    */
   pw = SECU_FilePasswd(slot, retry, pwdata->data);
   pwdata->source = PW_PLAINTEXT;
   pwdata->data = PL_strdup(pw);
   /* it's already been dup'ed */
   return pw;
     case PW_EXTERNAL:
-  sprintf(prompt, 
+  sprintf(prompt,
           "Press Enter, then enter PIN for \"%s\" on external device.\n",
     PK11_GetTokenName(slot));
   pw = GetPasswordString(NULL, prompt);
   if (pw) {
     memset(pw, 0, PORT_Strlen(pw));
     PORT_Free(pw);
   }
       /* Fall Through */
--- a/modules/libmar/src/mar.h
+++ b/modules/libmar/src/mar.h
@@ -117,19 +117,19 @@ int mar_read(MarFile *mar, const MarItem
  * @param dest      The path to the file to create.  This path must be
  *                  compatible with fopen.
  * @param numfiles  The number of files to store in the archive.
  * @param files     The list of null-terminated file paths.  Each file
  *                  path must be compatible with fopen.
  * @param infoBlock The information to store in the product information block.
  * @return          A non-zero value if an error occurs.
  */
-int mar_create(const char *dest, 
-               int numfiles, 
-               char **files, 
+int mar_create(const char *dest,
+               int numfiles,
+               char **files,
                struct ProductInformationBlock *infoBlock);
 
 /**
  * Extract a MAR file to the current working directory.
  * @param path      The path to the MAR file to extract.  This path must be
  *                  compatible with fopen.
  * @return          A non-zero value if an error occurs.
  */
@@ -142,58 +142,58 @@ int mar_extract(const char *path);
  * write whatever error messages it sees fit. The caller must free the returned
  * buffer using free().
  *
  * @param filePath The path to the file that should be read.
  * @param maxSize  The maximum valid file size.
  * @param data     On success, *data will point to a newly-allocated buffer
  *                 with the file's contents in it.
  * @param size     On success, *size will be the size of the created buffer.
- * 
+ *
  * @return 0 on success, -1 on error
  */
 int mar_read_entire_file(const char * filePath,
                          uint32_t maxSize,
                          /*out*/ const uint8_t * *data,
                          /*out*/ uint32_t *size);
 
 /**
  * Verifies a MAR file by verifying each signature with the corresponding
  * certificate. That is, the first signature will be verified using the first
  * certificate given, the second signature will be verified using the second
  * certificate given, etc. The signature count must exactly match the number of
  * certificates given, and all signature verifications must succeed.
- * We do not check that the certificate was issued by any trusted authority. 
- * We assume it to be self-signed.  We do not check whether the certificate 
+ * We do not check that the certificate was issued by any trusted authority.
+ * We assume it to be self-signed.  We do not check whether the certificate
  * is valid for this usage.
- * 
+ *
  * @param mar            The already opened MAR file.
  * @param certData       Pointer to the first element in an array of certificate
  *                       file data.
  * @param certDataSizes  Pointer to the first element in an array for size of
  *                       the cert data.
  * @param certCount      The number of elements in certData and certDataSizes
  * @return 0 on success
  *         a negative number if there was an error
  *         a positive number if the signature does not verify
  */
 int mar_verify_signatures(MarFile *mar,
                           const uint8_t * const *certData,
                           const uint32_t *certDataSizes,
                           uint32_t certCount);
 
-/** 
+/**
  * Reads the product info block from the MAR file's additional block section.
  * The caller is responsible for freeing the fields in infoBlock
  * if the return is successful.
  *
  * @param infoBlock Out parameter for where to store the result to
  * @return 0 on success, -1 on failure
 */
 int
-mar_read_product_info_block(MarFile *mar, 
+mar_read_product_info_block(MarFile *mar,
                             struct ProductInformationBlock *infoBlock);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif  /* MAR_H__ */
--- a/modules/libmar/src/mar_cmdline.h
+++ b/modules/libmar/src/mar_cmdline.h
@@ -18,61 +18,61 @@ struct ProductInformationBlock;
  *
  * @param path                   The path of the MAR file to check.
  * @param hasSignatureBlock      Optional out parameter specifying if the MAR
  *                               file has a signature block or not.
  * @param numSignatures          Optional out parameter for storing the number
  *                               of signatures in the MAR file.
  * @param hasAdditionalBlocks    Optional out parameter specifying if the MAR
  *                               file has additional blocks or not.
- * @param offsetAdditionalBlocks Optional out parameter for the offset to the 
+ * @param offsetAdditionalBlocks Optional out parameter for the offset to the
  *                               first additional block. Value is only valid if
  *                               hasAdditionalBlocks is not equal to 0.
  * @param numAdditionalBlocks    Optional out parameter for the number of
  *                               additional blocks.  Value is only valid if
  *                               has_additional_blocks is not equal to 0.
  * @return 0 on success and non-zero on failure.
  */
-int get_mar_file_info(const char *path, 
+int get_mar_file_info(const char *path,
                       int *hasSignatureBlock,
                       uint32_t *numSignatures,
                       int *hasAdditionalBlocks,
                       uint32_t *offsetAdditionalBlocks,
                       uint32_t *numAdditionalBlocks);
 
-/** 
+/**
  * Reads the product info block from the MAR file's additional block section.
  * The caller is responsible for freeing the fields in infoBlock
  * if the return is successful.
  *
  * @param infoBlock Out parameter for where to store the result to
  * @return 0 on success, -1 on failure
 */
 int
-read_product_info_block(char *path, 
+read_product_info_block(char *path,
                         struct ProductInformationBlock *infoBlock);
 
-/** 
+/**
  * Refreshes the product information block with the new information.
  * The input MAR must not be signed or the function call will fail.
- * 
+ *
  * @param path             The path to the MAR file whose product info block
  *                         should be refreshed.
  * @param infoBlock        Out parameter for where to store the result to
  * @return 0 on success, -1 on failure
 */
 int
 refresh_product_info_block(const char *path,
                            struct ProductInformationBlock *infoBlock);
 
 /**
  * Writes out a copy of the MAR at src but with the signature block stripped.
  *
  * @param  src  The path of the source MAR file
- * @param  dest The path of the MAR file to write out that 
+ * @param  dest The path of the MAR file to write out that
                 has no signature block
  * @return 0 on success
  *         -1 on error
 */
 int
 strip_signature_block(const char *src, const char * dest);
 
 /**
--- a/modules/libmar/src/mar_create.c
+++ b/modules/libmar/src/mar_create.c
@@ -32,17 +32,17 @@ struct MarItemStack {
  * of memory.
  */
 static int mar_push(struct MarItemStack *stack, uint32_t length, uint32_t flags,
                     const char *name) {
   int namelen;
   uint32_t n_offset, n_length, n_flags;
   uint32_t size;
   char *data;
-  
+
   namelen = strlen(name);
   size = MAR_ITEM_SIZE(namelen);
 
   if (stack->size_allocated - stack->size_used < size) {
     /* increase size of stack */
     size_t size_needed = ROUND_UP(stack->size_used + size, BLOCKSIZE);
     stack->head = realloc(stack->head, size_needed);
     if (!stack->head)
@@ -61,17 +61,17 @@ static int mar_push(struct MarItemStack 
 
   memcpy(data, &n_length, sizeof(n_length));
   data += sizeof(n_length);
 
   memcpy(data, &n_flags, sizeof(n_flags));
   data += sizeof(n_flags);
 
   memcpy(data, name, namelen + 1);
-  
+
   stack->size_used += size;
   stack->last_offset += length;
   return 0;
 }
 
 static int mar_concat_file(FILE *fp, const char *path) {
   FILE *in;
   char buf[BLOCKSIZE];
@@ -95,34 +95,34 @@ static int mar_concat_file(FILE *fp, con
   fclose(in);
   return rv;
 }
 
 /**
  * Writes out the product information block to the specified file.
  *
  * @param fp           The opened MAR file being created.
- * @param stack        A pointer to the MAR item stack being used to create 
+ * @param stack        A pointer to the MAR item stack being used to create
  *                     the MAR
  * @param infoBlock    The product info block to store in the file.
  * @return 0 on success.
 */
 static int
-mar_concat_product_info_block(FILE *fp, 
+mar_concat_product_info_block(FILE *fp,
                               struct MarItemStack *stack,
                               struct ProductInformationBlock *infoBlock)
 {
   char buf[PIB_MAX_MAR_CHANNEL_ID_SIZE + PIB_MAX_PRODUCT_VERSION_SIZE];
   uint32_t additionalBlockID = 1, infoBlockSize, unused;
-  if (!fp || !infoBlock || 
+  if (!fp || !infoBlock ||
       !infoBlock->MARChannelID ||
       !infoBlock->productVersion) {
     return -1;
   }
- 
+
   /* The MAR channel name must be < 64 bytes per the spec */
   if (strlen(infoBlock->MARChannelID) > PIB_MAX_MAR_CHANNEL_ID_SIZE) {
     return -1;
   }
 
   /* The product version must be < 32 bytes per the spec */
   if (strlen(infoBlock->productVersion) > PIB_MAX_PRODUCT_VERSION_SIZE) {
     return -1;
@@ -137,75 +137,75 @@ mar_concat_product_info_block(FILE *fp,
                   PIB_MAX_MAR_CHANNEL_ID_SIZE +
                   PIB_MAX_PRODUCT_VERSION_SIZE + 2;
   if (stack) {
     stack->last_offset += infoBlockSize;
   }
 
   /* Write out the product info block size */
   infoBlockSize = htonl(infoBlockSize);
-  if (fwrite(&infoBlockSize, 
+  if (fwrite(&infoBlockSize,
       sizeof(infoBlockSize), 1, fp) != 1) {
     return -1;
   }
   infoBlockSize = ntohl(infoBlockSize);
 
   /* Write out the product info block ID */
   additionalBlockID = htonl(additionalBlockID);
-  if (fwrite(&additionalBlockID, 
+  if (fwrite(&additionalBlockID,
       sizeof(additionalBlockID), 1, fp) != 1) {
     return -1;
   }
   additionalBlockID = ntohl(additionalBlockID);
 
   /* Write out the channel name and NULL terminator */
-  if (fwrite(infoBlock->MARChannelID, 
+  if (fwrite(infoBlock->MARChannelID,
       strlen(infoBlock->MARChannelID) + 1, 1, fp) != 1) {
     return -1;
   }
 
   /* Write out the product version string and NULL terminator */
-  if (fwrite(infoBlock->productVersion, 
+  if (fwrite(infoBlock->productVersion,
       strlen(infoBlock->productVersion) + 1, 1, fp) != 1) {
     return -1;
   }
 
   /* Write out the rest of the block that is unused */
   unused = infoBlockSize - (sizeof(infoBlockSize) +
                             sizeof(additionalBlockID) +
-                            strlen(infoBlock->MARChannelID) + 
+                            strlen(infoBlock->MARChannelID) +
                             strlen(infoBlock->productVersion) + 2);
   memset(buf, 0, sizeof(buf));
   if (fwrite(buf, unused, 1, fp) != 1) {
     return -1;
   }
   return 0;
 }
 
-/** 
+/**
  * Refreshes the product information block with the new information.
  * The input MAR must not be signed or the function call will fail.
- * 
+ *
  * @param path             The path to the MAR file whose product info block
  *                         should be refreshed.
  * @param infoBlock        Out parameter for where to store the result to
  * @return 0 on success, -1 on failure
 */
 int
 refresh_product_info_block(const char *path,
                            struct ProductInformationBlock *infoBlock)
 {
   FILE *fp ;
   int rv;
   uint32_t numSignatures, additionalBlockSize, additionalBlockID,
     offsetAdditionalBlocks, numAdditionalBlocks, i;
   int additionalBlocks, hasSignatureBlock;
   int64_t oldPos;
 
-  rv = get_mar_file_info(path, 
+  rv = get_mar_file_info(path,
                          &hasSignatureBlock,
                          &numSignatures,
                          &additionalBlocks,
                          &offsetAdditionalBlocks,
                          &numAdditionalBlocks);
   if (rv) {
     fprintf(stderr, "ERROR: Could not obtain MAR information.\n");
     return -1;
@@ -228,27 +228,27 @@ refresh_product_info_block(const char *p
     return -1;
   }
 
   for (i = 0; i < numAdditionalBlocks; ++i) {
     /* Get the position of the start of this block */
     oldPos = ftello(fp);
 
     /* Read the additional block size */
-    if (fread(&additionalBlockSize, 
-              sizeof(additionalBlockSize), 
+    if (fread(&additionalBlockSize,
+              sizeof(additionalBlockSize),
               1, fp) != 1) {
       fclose(fp);
       return -1;
     }
     additionalBlockSize = ntohl(additionalBlockSize);
 
     /* Read the additional block ID */
-    if (fread(&additionalBlockID, 
-              sizeof(additionalBlockID), 
+    if (fread(&additionalBlockID,
+              sizeof(additionalBlockID),
               1, fp) != 1) {
       fclose(fp);
       return -1;
     }
     additionalBlockID = ntohl(additionalBlockID);
 
     if (PRODUCT_INFO_BLOCK_ID == additionalBlockID) {
       if (fseeko(fp, oldPos, SEEK_SET)) {
@@ -286,21 +286,21 @@ refresh_product_info_block(const char *p
  * @param dest      The path to the file to create.  This path must be
  *                  compatible with fopen.
  * @param numfiles  The number of files to store in the archive.
  * @param files     The list of null-terminated file paths.  Each file
  *                  path must be compatible with fopen.
  * @param infoBlock The information to store in the product information block.
  * @return A non-zero value if an error occurs.
  */
-int mar_create(const char *dest, int 
-               num_files, char **files, 
+int mar_create(const char *dest, int
+               num_files, char **files,
                struct ProductInformationBlock *infoBlock) {
   struct MarItemStack stack;
-  uint32_t offset_to_index = 0, size_of_index, 
+  uint32_t offset_to_index = 0, size_of_index,
     numSignatures, numAdditionalSections;
   uint64_t sizeOfEntireMAR = 0;
   struct stat st;
   FILE *fp;
   int i, rv = -1;
 
   memset(&stack, 0, sizeof(stack));
 
@@ -310,37 +310,37 @@ int mar_create(const char *dest, int
     return -1;
   }
 
   if (fwrite(MAR_ID, MAR_ID_SIZE, 1, fp) != 1)
     goto failure;
   if (fwrite(&offset_to_index, sizeof(uint32_t), 1, fp) != 1)
     goto failure;
 
-  stack.last_offset = MAR_ID_SIZE + 
+  stack.last_offset = MAR_ID_SIZE +
                       sizeof(offset_to_index) +
-                      sizeof(numSignatures) + 
+                      sizeof(numSignatures) +
                       sizeof(numAdditionalSections) +
                       sizeof(sizeOfEntireMAR);
 
   /* We will circle back on this at the end of the MAR creation to fill it */
   if (fwrite(&sizeOfEntireMAR, sizeof(sizeOfEntireMAR), 1, fp) != 1) {
     goto failure;
   }
 
   /* Write out the number of signatures, for now only at most 1 is supported */
   numSignatures = 0;
   if (fwrite(&numSignatures, sizeof(numSignatures), 1, fp) != 1) {
     goto failure;
   }
 
-  /* Write out the number of additional sections, for now just 1 
+  /* Write out the number of additional sections, for now just 1
      for the product info block */
   numAdditionalSections = htonl(1);
-  if (fwrite(&numAdditionalSections, 
+  if (fwrite(&numAdditionalSections,
              sizeof(numAdditionalSections), 1, fp) != 1) {
     goto failure;
   }
   numAdditionalSections = ntohl(numAdditionalSections);
 
   if (mar_concat_product_info_block(fp, &stack, infoBlock)) {
     goto failure;
   }
@@ -361,39 +361,39 @@ int mar_create(const char *dest, int
 
   /* write out the index (prefixed with length of index) */
   size_of_index = htonl(stack.size_used);
   if (fwrite(&size_of_index, sizeof(size_of_index), 1, fp) != 1)
     goto failure;
   if (fwrite(stack.head, stack.size_used, 1, fp) != 1)
     goto failure;
 
-  /* To protect against invalid MAR files, we assumes that the MAR file 
+  /* To protect against invalid MAR files, we assumes that the MAR file
      size is less than or equal to MAX_SIZE_OF_MAR_FILE. */
   if (ftell(fp) > MAX_SIZE_OF_MAR_FILE) {
     goto failure;
   }
 
   /* write out offset to index file in network byte order */
   offset_to_index = htonl(stack.last_offset);
   if (fseek(fp, MAR_ID_SIZE, SEEK_SET))
     goto failure;
   if (fwrite(&offset_to_index, sizeof(offset_to_index), 1, fp) != 1)
     goto failure;
   offset_to_index = ntohl(stack.last_offset);
-  
+
   sizeOfEntireMAR = ((uint64_t)stack.last_offset) +
                     stack.size_used +
                     sizeof(size_of_index);
   sizeOfEntireMAR = HOST_TO_NETWORK64(sizeOfEntireMAR);
   if (fwrite(&sizeOfEntireMAR, sizeof(sizeOfEntireMAR), 1, fp) != 1)
     goto failure;
   sizeOfEntireMAR = NETWORK_TO_HOST64(sizeOfEntireMAR);
 
   rv = 0;
-failure: 
+failure:
   if (stack.head)
     free(stack.head);
   fclose(fp);
   if (rv)
     remove(dest);
   return rv;
 }
--- a/modules/libmar/src/mar_private.h
+++ b/modules/libmar/src/mar_private.h
@@ -12,51 +12,51 @@
 #include <stdint.h>
 
 #define BLOCKSIZE 4096
 #define ROUND_UP(n, incr) (((n) / (incr) + 1) * (incr))
 
 #define MAR_ID "MAR1"
 #define MAR_ID_SIZE 4
 
-/* The signature block comes directly after the header block 
+/* The signature block comes directly after the header block
    which is 16 bytes */
 #define SIGNATURE_BLOCK_OFFSET 16
 
 /* Make sure the file is less than 500MB.  We do this to protect against
    invalid MAR files. */
 #define MAX_SIZE_OF_MAR_FILE ((int64_t)524288000)
 
 /* Existing code makes assumptions that the file size is
    smaller than LONG_MAX. */
 MOZ_STATIC_ASSERT(MAX_SIZE_OF_MAR_FILE < ((int64_t)LONG_MAX),
                   "max mar file size is too big");
 
-/* We store at most the size up to the signature block + 4 
+/* We store at most the size up to the signature block + 4
    bytes per BLOCKSIZE bytes */
 MOZ_STATIC_ASSERT(sizeof(BLOCKSIZE) < \
                   (SIGNATURE_BLOCK_OFFSET + sizeof(uint32_t)),
                   "BLOCKSIZE is too big");
 
 /* The maximum size of any signature supported by current and future
    implementations of the signmar program. */
 #define MAX_SIGNATURE_LENGTH 2048
 
-/* Each additional block has a unique ID.  
+/* Each additional block has a unique ID.
    The product information block has an ID of 1. */
 #define PRODUCT_INFO_BLOCK_ID 1
 
 #define MAR_ITEM_SIZE(namelen) (3*sizeof(uint32_t) + (namelen) + 1)
 
 /* Product Information Block (PIB) constants */
 #define PIB_MAX_MAR_CHANNEL_ID_SIZE 63
 #define PIB_MAX_PRODUCT_VERSION_SIZE 31
 
 /* The mar program is compiled as a host bin so we don't have access to NSPR at
-   runtime.  For that reason we use ntohl, htonl, and define HOST_TO_NETWORK64 
+   runtime.  For that reason we use ntohl, htonl, and define HOST_TO_NETWORK64
    instead of the NSPR equivalents. */
 #ifdef XP_WIN
 #include <winsock2.h>
 #define ftello _ftelli64
 #define fseeko _fseeki64
 #else
 #define _FILE_OFFSET_BITS 64
 #include <netinet/in.h>
--- a/modules/libmar/src/mar_read.c
+++ b/modules/libmar/src/mar_read.c
@@ -28,17 +28,17 @@ static uint32_t mar_hash_name(const char
 
   return val % TABLESIZE;
 }
 
 static int mar_insert_item(MarFile *mar, const char *name, int namelen,
                            uint32_t offset, uint32_t length, uint32_t flags) {
   MarItem *item, *root;
   uint32_t hash;
-  
+
   item = (MarItem *) malloc(sizeof(MarItem) + namelen);
   if (!item)
     return -1;
   item->next = NULL;
   item->offset = offset;
   item->length = length;
   item->flags = flags;
   memcpy(item->name, name, namelen + 1);
@@ -218,33 +218,33 @@ void mar_close(MarFile *mar) {
  *
  * @param fp                     An opened MAR file in read mode.
  * @param hasSignatureBlock      Optional out parameter specifying if the MAR
  *                               file has a signature block or not.
  * @param numSignatures          Optional out parameter for storing the number
  *                               of signatures in the MAR file.
  * @param hasAdditionalBlocks    Optional out parameter specifying if the MAR
  *                               file has additional blocks or not.
- * @param offsetAdditionalBlocks Optional out parameter for the offset to the 
+ * @param offsetAdditionalBlocks Optional out parameter for the offset to the
  *                               first additional block. Value is only valid if
  *                               hasAdditionalBlocks is not equal to 0.
  * @param numAdditionalBlocks    Optional out parameter for the number of
  *                               additional blocks.  Value is only valid if
  *                               hasAdditionalBlocks is not equal to 0.
  * @return 0 on success and non-zero on failure.
  */
-int get_mar_file_info_fp(FILE *fp, 
+int get_mar_file_info_fp(FILE *fp,
                          int *hasSignatureBlock,
                          uint32_t *numSignatures,
                          int *hasAdditionalBlocks,
                          uint32_t *offsetAdditionalBlocks,
                          uint32_t *numAdditionalBlocks)
 {
   uint32_t offsetToIndex, offsetToContent, signatureCount, signatureLen, i;
-  
+
   /* One of hasSignatureBlock or hasAdditionalBlocks must be non NULL */
   if (!hasSignatureBlock && !hasAdditionalBlocks) {
     return -1;
   }
 
 
   /* Skip to the start of the offset index */
   if (fseek(fp, MAR_ID_SIZE, SEEK_SET)) {
@@ -265,18 +265,18 @@ int get_mar_file_info_fp(FILE *fp,
 
     /* Read the number of signatures field */
     if (fread(numSignatures, sizeof(*numSignatures), 1, fp) != 1) {
       return -1;
     }
     *numSignatures = ntohl(*numSignatures);
   }
 
-  /* Skip to the first index entry past the index size field 
-     We do it in 2 calls because offsetToIndex + sizeof(uint32_t) 
+  /* Skip to the first index entry past the index size field
+     We do it in 2 calls because offsetToIndex + sizeof(uint32_t)
      could oerflow in theory. */
   if (fseek(fp, offsetToIndex, SEEK_SET)) {
     return -1;
   }
 
   if (fseek(fp, sizeof(uint32_t), SEEK_CUR)) {
     return -1;
   }
@@ -291,17 +291,17 @@ int get_mar_file_info_fp(FILE *fp,
   if (hasSignatureBlock) {
     if (offsetToContent == MAR_ID_SIZE + sizeof(uint32_t)) {
       *hasSignatureBlock = 0;
     } else {
       *hasSignatureBlock = 1;
     }
   }
 
-  /* If the caller doesn't care about the product info block 
+  /* If the caller doesn't care about the product info block
      value, then just return */
   if (!hasAdditionalBlocks) {
     return 0;
   }
 
    /* Skip to the start of the signature block */
   if (fseeko(fp, SIGNATURE_BLOCK_OFFSET, SEEK_SET)) {
     return -1;
@@ -346,102 +346,102 @@ int get_mar_file_info_fp(FILE *fp,
       if (fread(numAdditionalBlocks, sizeof(uint32_t), 1, fp) != 1) {
         return -1;
       }
       *numAdditionalBlocks = ntohl(*numAdditionalBlocks);
       if (offsetAdditionalBlocks) {
         *offsetAdditionalBlocks = ftell(fp);
       }
     } else if (offsetAdditionalBlocks) {
-      /* numAdditionalBlocks is not specified but offsetAdditionalBlocks 
+      /* numAdditionalBlocks is not specified but offsetAdditionalBlocks
          is, so fill it! */
       *offsetAdditionalBlocks = ftell(fp) + sizeof(uint32_t);
     }
   }
 
   return 0;
 }
 
-/** 
+/**
  * Reads the product info block from the MAR file's additional block section.
  * The caller is responsible for freeing the fields in infoBlock
  * if the return is successful.
  *
  * @param infoBlock Out parameter for where to store the result to
  * @return 0 on success, -1 on failure
 */
 int
-read_product_info_block(char *path, 
+read_product_info_block(char *path,
                         struct ProductInformationBlock *infoBlock)
 {
   int rv;
   MarFile mar;
   mar.fp = fopen(path, "rb");
   if (!mar.fp) {
     fprintf(stderr, "ERROR: could not open file in read_product_info_block()\n");
     perror(path);
     return -1;
   }
   rv = mar_read_product_info_block(&mar, infoBlock);
   fclose(mar.fp);
   return rv;
 }
 
-/** 
+/**
  * Reads the product info block from the MAR file's additional block section.
  * The caller is responsible for freeing the fields in infoBlock
  * if the return is successful.
  *
  * @param infoBlock Out parameter for where to store the result to
  * @return 0 on success, -1 on failure
 */
 int
-mar_read_product_info_block(MarFile *mar, 
+mar_read_product_info_block(MarFile *mar,
                             struct ProductInformationBlock *infoBlock)
 {
   uint32_t i, offsetAdditionalBlocks, numAdditionalBlocks,
     additionalBlockSize, additionalBlockID;
   int hasAdditionalBlocks;
 
-  /* The buffer size is 97 bytes because the MAR channel name < 64 bytes, and 
+  /* The buffer size is 97 bytes because the MAR channel name < 64 bytes, and
      product version < 32 bytes + 3 NULL terminator bytes. */
   char buf[97] = { '\0' };
   if (get_mar_file_info_fp(mar->fp, NULL, NULL,
                            &hasAdditionalBlocks,
                            &offsetAdditionalBlocks,
                            &numAdditionalBlocks) != 0) {
     return -1;
   }
   for (i = 0; i < numAdditionalBlocks; ++i) {
     /* Read the additional block size */
-    if (fread(&additionalBlockSize, 
-              sizeof(additionalBlockSize), 
+    if (fread(&additionalBlockSize,
+              sizeof(additionalBlockSize),
               1, mar->fp) != 1) {
       return -1;
     }
-    additionalBlockSize = ntohl(additionalBlockSize) - 
-                          sizeof(additionalBlockSize) - 
+    additionalBlockSize = ntohl(additionalBlockSize) -
+                          sizeof(additionalBlockSize) -
                           sizeof(additionalBlockID);
 
     /* Read the additional block ID */
-    if (fread(&additionalBlockID, 
-              sizeof(additionalBlockID), 
+    if (fread(&additionalBlockID,
+              sizeof(additionalBlockID),
               1, mar->fp) != 1) {
       return -1;
     }
     additionalBlockID = ntohl(additionalBlockID);
 
     if (PRODUCT_INFO_BLOCK_ID == additionalBlockID) {
       const char *location;
       int len;
 
       /* This block must be at most 104 bytes.
-         MAR channel name < 64 bytes, and product version < 32 bytes + 3 NULL 
-         terminator bytes. We only check for 96 though because we remove 8 
-         bytes above from the additionalBlockSize: We subtract 
+         MAR channel name < 64 bytes, and product version < 32 bytes + 3 NULL
+         terminator bytes. We only check for 96 though because we remove 8
+         bytes above from the additionalBlockSize: We subtract
          sizeof(additionalBlockSize) and sizeof(additionalBlockID) */
       if (additionalBlockSize > 96) {
         return -1;
       }
 
     if (fread(buf, additionalBlockSize, 1, mar->fp) != 1) {
         return -1;
       }
@@ -461,19 +461,19 @@ mar_read_product_info_block(MarFile *mar
       /* Extract the version from the buffer */
       len = strlen(location);
       infoBlock->productVersion = location;
       if (len >= 32) {
         infoBlock->MARChannelID = NULL;
         infoBlock->productVersion = NULL;
         return -1;
       }
-      infoBlock->MARChannelID = 
+      infoBlock->MARChannelID =
         strdup(infoBlock->MARChannelID);
-      infoBlock->productVersion = 
+      infoBlock->productVersion =
         strdup(infoBlock->productVersion);
       return 0;
     } else {
       /* This is not the additional block you're looking for. Move along. */
       if (fseek(mar->fp, additionalBlockSize, SEEK_CUR)) {
         return -1;
       }
     }
@@ -553,38 +553,38 @@ int mar_read(MarFile *mar, const MarItem
  *
  * @param path                   The path of the MAR file to check.
  * @param hasSignatureBlock      Optional out parameter specifying if the MAR
  *                               file has a signature block or not.
  * @param numSignatures          Optional out parameter for storing the number
  *                               of signatures in the MAR file.
  * @param hasAdditionalBlocks    Optional out parameter specifying if the MAR
  *                               file has additional blocks or not.
- * @param offsetAdditionalBlocks Optional out parameter for the offset to the 
+ * @param offsetAdditionalBlocks Optional out parameter for the offset to the
  *                               first additional block. Value is only valid if
  *                               hasAdditionalBlocks is not equal to 0.
  * @param numAdditionalBlocks    Optional out parameter for the number of
  *                               additional blocks.  Value is only valid if
  *                               has_additional_blocks is not equal to 0.
  * @return 0 on success and non-zero on failure.
  */
-int get_mar_file_info(const char *path, 
+int get_mar_file_info(const char *path,
                       int *hasSignatureBlock,
                       uint32_t *numSignatures,
                       int *hasAdditionalBlocks,
                       uint32_t *offsetAdditionalBlocks,
                       uint32_t *numAdditionalBlocks)
 {
   int rv;
   FILE *fp = fopen(path, "rb");
   if (!fp) {
     fprintf(stderr, "ERROR: could not open file in get_mar_file_info()\n");
     perror(path);
     return -1;
   }
 
-  rv = get_mar_file_info_fp(fp, hasSignatureBlock, 
+  rv = get_mar_file_info_fp(fp, hasSignatureBlock,
                             numSignatures, hasAdditionalBlocks,
                             offsetAdditionalBlocks, numAdditionalBlocks);
 
   fclose(fp);
   return rv;
 }
--- a/modules/libmar/tool/mar.c
+++ b/modules/libmar/tool/mar.c
@@ -23,17 +23,17 @@
 #include "nss.h"
 #include "pk11pub.h"
 int NSSInitCryptoContext(const char *NSSConfigDir);
 #endif
 
 int mar_repackage_and_sign(const char *NSSConfigDir,
                            const char * const *certNames,
                            uint32_t certCount,
-                           const char *src, 
+                           const char *src,
                            const char * dest);
 
 static void print_version() {
   printf("Version: %s\n", MOZ_APP_VERSION);
   printf("Default Channel ID: %s\n", MAR_CHANNEL_ID);
 }
 
 static void print_usage() {
@@ -87,18 +87,18 @@ static void print_usage() {
   printf("  mar [-H MARChannelID] [-V ProductVersion] [-C workingDir] "
          "-i unsigned_archive_to_refresh.mar\n");
 
   printf("Print executable version:\n");
   printf("  mar --version\n");
   printf("This program does not handle unicode file paths properly\n");
 }
 
-static int mar_test_callback(MarFile *mar, 
-                             const MarItem *item, 
+static int mar_test_callback(MarFile *mar,
+                             const MarItem *item,
                              void *unused) {
   printf("%u\t0%o\t%s\n", item->length, item->flags, item->name);
   return 0;
 }
 
 static int mar_test(const char *path) {
   MarFile *mar;
 
@@ -252,28 +252,28 @@ int main(int argc, char **argv) {
     infoBlock.MARChannelID = MARChannelID;
     infoBlock.productVersion = productVersion;
     return refresh_product_info_block(argv[2], &infoBlock);
   }
   case 'T': {
     struct ProductInformationBlock infoBlock;
     uint32_t numSignatures, numAdditionalBlocks;
     int hasSignatureBlock, hasAdditionalBlock;
-    if (!get_mar_file_info(argv[2], 
+    if (!get_mar_file_info(argv[2],
                            &hasSignatureBlock,
                            &numSignatures,
-                           &hasAdditionalBlock, 
+                           &hasAdditionalBlock,
                            NULL, &numAdditionalBlocks)) {
       if (hasSignatureBlock) {
-        printf("Signature block found with %d signature%s\n", 
-               numSignatures, 
+        printf("Signature block found with %d signature%s\n",
+               numSignatures,
                numSignatures != 1 ? "s" : "");
       }
       if (hasAdditionalBlock) {
-        printf("%d additional block%s found:\n", 
+        printf("%d additional block%s found:\n",
                numAdditionalBlocks,
                numAdditionalBlocks != 1 ? "s" : "");
       }
 
       rv = read_product_info_block(argv[2], &infoBlock);
       if (!rv) {
         printf("  - Product Information Block:\n");
         printf("    - MAR channel name: %s\n"
@@ -390,17 +390,17 @@ int main(int argc, char **argv) {
 #else
       /* certBuffers[k] is owned by certs[k] so don't free it */
       CERT_DestroyCertificate(certs[k]);
 #endif
     }
     if (rv) {
       /* Determine if the source MAR file has the new fields for signing */
       int hasSignatureBlock;
-      if (get_mar_file_info(argv[2], &hasSignatureBlock, 
+      if (get_mar_file_info(argv[2], &hasSignatureBlock,
                             NULL, NULL, NULL, NULL)) {
         fprintf(stderr, "ERROR: could not determine if MAR is old or new.\n");
       } else if (!hasSignatureBlock) {
         fprintf(stderr, "ERROR: The MAR file is in the old format so has"
                         " no signature to verify.\n");
       }
     }
 #if (!defined(XP_WIN) && !defined(XP_MACOSX)) || defined(MAR_NSS)
--- a/modules/libmar/verify/cryptox.c
+++ b/modules/libmar/verify/cryptox.c
@@ -9,19 +9,19 @@
 #endif
 
 #include <stdlib.h>
 #include <stdio.h>
 #include "cryptox.h"
 
 #if defined(MAR_NSS)
 
-/** 
+/**
  * Loads the public key for the specified cert name from the NSS store.
- * 
+ *
  * @param certData  The DER-encoded X509 certificate to extract the key from.
  * @param certDataSize The size of certData.
  * @param publicKey Out parameter for the public key to use.
  * @return CryptoX_Success on success, CryptoX_Error on error.
 */
 CryptoX_Result
 NSS_LoadPublicKey(const unsigned char *certData, unsigned int certDataSize,
                   SECKEYPublicKey **publicKey)
@@ -44,33 +44,33 @@ NSS_LoadPublicKey(const unsigned char *c
 
   if (!*publicKey) {
     return CryptoX_Error;
   }
   return CryptoX_Success;
 }
 
 CryptoX_Result
-NSS_VerifyBegin(VFYContext **ctx, 
+NSS_VerifyBegin(VFYContext **ctx,
                 SECKEYPublicKey * const *publicKey)
 {
   SECStatus status;
   if (!ctx || !publicKey || !*publicKey) {
     return CryptoX_Error;
   }
 
   /* Check that the key length is large enough for our requirements */
-  if ((SECKEY_PublicKeyStrength(*publicKey) * 8) < 
+  if ((SECKEY_PublicKeyStrength(*publicKey) * 8) <
       XP_MIN_SIGNATURE_LEN_IN_BYTES) {
-    fprintf(stderr, "ERROR: Key length must be >= %d bytes\n", 
+    fprintf(stderr, "ERROR: Key length must be >= %d bytes\n",
             XP_MIN_SIGNATURE_LEN_IN_BYTES);
     return CryptoX_Error;
   }
 
-  *ctx = VFY_CreateContext(*publicKey, NULL, 
+  *ctx = VFY_CreateContext(*publicKey, NULL,
                            SEC_OID_PKCS1_SHA384_WITH_RSA_ENCRYPTION, NULL);
   if (*ctx == NULL) {
     return CryptoX_Error;
   }
 
   status = VFY_Begin(*ctx);
   return SECSuccess == status ? CryptoX_Success : CryptoX_Error;
 }
@@ -79,18 +79,18 @@ NSS_VerifyBegin(VFYContext **ctx,
  * Verifies if a verify context matches the passed in signature.
  *
  * @param ctx          The verify context that the signature should match.
  * @param signature    The signature to match.
  * @param signatureLen The length of the signature.
  * @return CryptoX_Success on success, CryptoX_Error on error.
 */
 CryptoX_Result
-NSS_VerifySignature(VFYContext * const *ctx, 
-                    const unsigned char *signature, 
+NSS_VerifySignature(VFYContext * const *ctx,
+                    const unsigned char *signature,
                     unsigned int signatureLen)
 {
   SECItem signedItem;
   SECStatus status;
   if (!ctx || !signature || !*ctx) {
     return CryptoX_Error;
   }
 
@@ -108,131 +108,131 @@ NSS_VerifySignature(VFYContext * const *
  * @param pubKey    The public key to use on the signature.
  * @param signature The signature to check.
  * @param signatureLen The length of the signature.
  * @return CryptoX_Success on success, CryptoX_Error on error.
 */
 CryptoX_Result
 CryptoAPI_VerifySignature(HCRYPTHASH *hash,
                           HCRYPTKEY *pubKey,
-                          const BYTE *signature, 
+                          const BYTE *signature,
                           DWORD signatureLen)
 {
   DWORD i;
   BOOL result;
-/* Windows APIs expect the bytes in the signature to be in little-endian 
- * order, but we write the signature in big-endian order.  Other APIs like 
+/* Windows APIs expect the bytes in the signature to be in little-endian
+ * order, but we write the signature in big-endian order.  Other APIs like
  * NSS and OpenSSL expect big-endian order.
  */
   BYTE *signatureReversed;
   if (!hash || !pubKey || !signature || signatureLen < 1) {
     return CryptoX_Error;
   }
 
   signatureReversed = malloc(signatureLen);
   if (!signatureReversed) {
     return CryptoX_Error;
   }
 
   for (i = 0; i < signatureLen; i++) {
-    signatureReversed[i] = signature[signatureLen - 1 - i]; 
+    signatureReversed[i] = signature[signatureLen - 1 - i];
   }
   result = CryptVerifySignature(*hash, signatureReversed,
                                 signatureLen, *pubKey, NULL, 0);
   free(signatureReversed);
   return result ? CryptoX_Success : CryptoX_Error;
 }
 
-/** 
+/**
  * Obtains the public key for the passed in cert data
- * 
+ *
  * @param provider       The cyrto provider
  * @param certData       Data of the certificate to extract the public key from
  * @param sizeOfCertData The size of the certData buffer
  * @param certStore      Pointer to the handle of the certificate store to use
  * @param CryptoX_Success on success
 */
 CryptoX_Result
-CryptoAPI_LoadPublicKey(HCRYPTPROV provider, 
+CryptoAPI_LoadPublicKey(HCRYPTPROV provider,
                         BYTE *certData,
                         DWORD sizeOfCertData,
                         HCRYPTKEY *publicKey)
 {
   CRYPT_DATA_BLOB blob;
   CERT_CONTEXT *context;
   if (!provider || !certData || !publicKey) {
     return CryptoX_Error;
   }
 
   blob.cbData = sizeOfCertData;
   blob.pbData = certData;
-  if (!CryptQueryObject(CERT_QUERY_OBJECT_BLOB, &blob, 
-                        CERT_QUERY_CONTENT_FLAG_CERT, 
-                        CERT_QUERY_FORMAT_FLAG_BINARY, 
-                        0, NULL, NULL, NULL, 
+  if (!CryptQueryObject(CERT_QUERY_OBJECT_BLOB, &blob,
+                        CERT_QUERY_CONTENT_FLAG_CERT,
+                        CERT_QUERY_FORMAT_FLAG_BINARY,
+                        0, NULL, NULL, NULL,
                         NULL, NULL, (const void **)&context)) {
     return CryptoX_Error;
   }
 
-  if (!CryptImportPublicKeyInfo(provider, 
+  if (!CryptImportPublicKeyInfo(provider,
                                 PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
                                 &context->pCertInfo->SubjectPublicKeyInfo,
                                 publicKey)) {
     CertFreeCertificateContext(context);
     return CryptoX_Error;
   }
 
   CertFreeCertificateContext(context);
   return CryptoX_Success;
 }
 
 /* Try to acquire context in this way:
   * 1. Enhanced provider without creating a new key set
   * 2. Enhanced provider with creating a new key set
   * 3. Default provider without creating a new key set
   * 4. Default provider without creating a new key set
-  * #2 and #4 should not be needed because of the CRYPT_VERIFYCONTEXT, 
+  * #2 and #4 should not be needed because of the CRYPT_VERIFYCONTEXT,
   * but we add it just in case.
   *
   * @param provider Out parameter containing the provider handle.
   * @return CryptoX_Success on success, CryptoX_Error on error.
  */
 CryptoX_Result
 CryptoAPI_InitCryptoContext(HCRYPTPROV *provider)
 {
-  if (!CryptAcquireContext(provider, 
-                           NULL, 
-                           MS_ENH_RSA_AES_PROV, 
-                           PROV_RSA_AES, 
+  if (!CryptAcquireContext(provider,
+                           NULL,
+                           MS_ENH_RSA_AES_PROV,
+                           PROV_RSA_AES,
                            CRYPT_VERIFYCONTEXT)) {
-    if (!CryptAcquireContext(provider, 
-                             NULL, 
-                             MS_ENH_RSA_AES_PROV, 
-                             PROV_RSA_AES, 
+    if (!CryptAcquireContext(provider,
+                             NULL,
+                             MS_ENH_RSA_AES_PROV,
+                             PROV_RSA_AES,
                              CRYPT_NEWKEYSET | CRYPT_VERIFYCONTEXT)) {
-      if (!CryptAcquireContext(provider, 
-                               NULL, 
-                               NULL, 
-                               PROV_RSA_AES, 
+      if (!CryptAcquireContext(provider,
+                               NULL,
+                               NULL,
+                               PROV_RSA_AES,
                                CRYPT_VERIFYCONTEXT)) {
-        if (!CryptAcquireContext(provider, 
-                                 NULL, 
-                                 NULL, 
-                                 PROV_RSA_AES, 
+        if (!CryptAcquireContext(provider,
+                                 NULL,
+                                 NULL,
+                                 PROV_RSA_AES,
                                  CRYPT_NEWKEYSET | CRYPT_VERIFYCONTEXT)) {
           *provider = CryptoX_InvalidHandleValue;
           return CryptoX_Error;
         }
       }
     }
   }
   return CryptoX_Success;
 }
 
-/** 
+/**
   * Begins a signature verification hash context
   *
   * @param provider The crypt provider to use
   * @param hash     Out parameter for a handle to the hash context
   * @return CryptoX_Success on success, CryptoX_Error on error.
 */
 CryptoX_Result
 CryptoAPI_VerifyBegin(HCRYPTPROV provider, HCRYPTHASH* hash)
@@ -243,17 +243,17 @@ CryptoAPI_VerifyBegin(HCRYPTPROV provide
   }
 
   *hash = (HCRYPTHASH)NULL;
   result = CryptCreateHash(provider, CALG_SHA_384,
                            0, 0, hash);
   return result ? CryptoX_Success : CryptoX_Error;
 }
 
-/** 
+/**
   * Updates a signature verification hash context
   *
   * @param hash The hash context to udpate
   * @param buf  The buffer to update the hash context with
   * @param len The size of the passed in buffer
   * @return CryptoX_Success on success, CryptoX_Error on error.
 */
 CryptoX_Result
--- a/modules/libmar/verify/cryptox.h
+++ b/modules/libmar/verify/cryptox.h
@@ -99,32 +99,32 @@ void CryptoMac_FreePublicKey(CryptoX_Pub
                                 aSignatureLen) \
   CryptoMac_VerifySignature(aInputData, aPublicKey, aSignature, aSignatureLen)
 #define CryptoX_FreeSignatureHandle(aInputData) \
   CryptoMac_FreeSignatureHandle(aInputData)
 #define CryptoX_FreePublicKey(aPublicKey) \
   CryptoMac_FreePublicKey(aPublicKey)
 #define CryptoX_FreeCertificate(aCertificate)
 
-#elif defined(XP_WIN) 
+#elif defined(XP_WIN)
 
 #include <windows.h>
 #include <wincrypt.h>
 
 CryptoX_Result CryptoAPI_InitCryptoContext(HCRYPTPROV *provider);
-CryptoX_Result CryptoAPI_LoadPublicKey(HCRYPTPROV hProv, 
+CryptoX_Result CryptoAPI_LoadPublicKey(HCRYPTPROV hProv,
                                        BYTE *certData,
                                        DWORD sizeOfCertData,
                                        HCRYPTKEY *publicKey);
 CryptoX_Result CryptoAPI_VerifyBegin(HCRYPTPROV provider, HCRYPTHASH* hash);
-CryptoX_Result CryptoAPI_VerifyUpdate(HCRYPTHASH* hash, 
+CryptoX_Result CryptoAPI_VerifyUpdate(HCRYPTHASH* hash,
                                       BYTE *buf, DWORD len);
 CryptoX_Result CryptoAPI_VerifySignature(HCRYPTHASH *hash,
                                          HCRYPTKEY *pubKey,
-                                         const BYTE *signature, 
+                                         const BYTE *signature,
                                          DWORD signatureLen);
 
 #define CryptoX_InvalidHandleValue ((ULONG_PTR)NULL)
 #define CryptoX_ProviderHandle HCRYPTPROV
 #define CryptoX_SignatureHandle HCRYPTHASH
 #define CryptoX_PublicKey HCRYPTKEY
 #define CryptoX_Certificate HCERTSTORE
 #define CryptoX_InitCryptoProvider(CryptoHandle) \
--- a/modules/libmar/verify/mar_verify.c
+++ b/modules/libmar/verify/mar_verify.c
@@ -70,40 +70,40 @@ int mar_verify_signatures_for_fp(FILE *f
                                  uint32_t *numVerified);
 
 /**
  * Reads the specified number of bytes from the file pointer and
  * stores them in the passed buffer.
  *
  * @param  fp     The file pointer to read from.
  * @param  buffer The buffer to store the read results.
- * @param  size   The number of bytes to read, buffer must be 
+ * @param  size   The number of bytes to read, buffer must be
  *                at least of this size.
  * @param  ctxs   Pointer to the first element in an array of verify context.
  * @param  count  The number of elements in ctxs
  * @param  err    The name of what is being written to in case of error.
  * @return  0 on success
  *         -1 on read error
  *         -2 on verify update error
 */
 int
-ReadAndUpdateVerifyContext(FILE *fp, 
+ReadAndUpdateVerifyContext(FILE *fp,
                            void *buffer,
-                           uint32_t size, 
+                           uint32_t size,
                            CryptoX_SignatureHandle *ctxs,
                            uint32_t count,
-                           const char *err) 
+                           const char *err)
 {
   uint32_t k;
   if (!fp || !buffer || !ctxs || count == 0 || !err) {
     fprintf(stderr, "ERROR: Invalid parameter specified.\n");
     return CryptoX_Error;
   }
 
-  if (!size) { 
+  if (!size) {
     return CryptoX_Success;
   }
 
   if (fread(buffer, size, 1, fp) != 1) {
     fprintf(stderr, "ERROR: Could not read %s\n", err);
     return CryptoX_Error;
   }
 
@@ -117,17 +117,17 @@ ReadAndUpdateVerifyContext(FILE *fp,
 }
 
 /**
  * Verifies a MAR file by verifying each signature with the corresponding
  * certificate. That is, the first signature will be verified using the first
  * certificate given, the second signature will be verified using the second
  * certificate given, etc. The signature count must exactly match the number of
  * certificates given, and all signature verifications must succeed.
- * 
+ *
  * @param  mar            The file who's signature should be calculated
  * @param  certData       Pointer to the first element in an array of
  *                        certificate data
  * @param  certDataSizes  Pointer to the first element in an array for size of
  *                        the data stored
  * @param  certCount      The number of elements in certData and certDataSizes
  * @return 0 on success
 */
@@ -135,30 +135,30 @@ int
 mar_verify_signatures(MarFile *mar,
                       const uint8_t * const *certData,
                       const uint32_t *certDataSizes,
                       uint32_t certCount) {
   int rv = -1;
   CryptoX_ProviderHandle provider = CryptoX_InvalidHandleValue;
   CryptoX_PublicKey keys[MAX_SIGNATURES];
   uint32_t k;
-  
+
   memset(keys, 0, sizeof(keys));
 
   if (!mar || !certData || !certDataSizes || certCount == 0) {
     fprintf(stderr, "ERROR: Invalid parameter specified.\n");
     goto failure;
   }
 
   if (!mar->fp) {
     fprintf(stderr, "ERROR: MAR file is not open.\n");
     goto failure;
   }
 
-  if (CryptoX_Failed(CryptoX_InitCryptoProvider(&provider))) { 
+  if (CryptoX_Failed(CryptoX_InitCryptoProvider(&provider))) {
     fprintf(stderr, "ERROR: Could not init crytpo library.\n");
     goto failure;
   }
 
   for (k = 0; k < certCount; ++k) {
     if (CryptoX_Failed(CryptoX_LoadPublicKey(provider, certData[k], certDataSizes[k],
                                              &keys[k]))) {
       fprintf(stderr, "ERROR: Could not load public key.\n");
@@ -201,18 +201,18 @@ mar_extract_and_verify_signatures_fp(FIL
 
   memset(signatureAlgorithmIDs, 0, sizeof(signatureAlgorithmIDs));
   memset(extractedSignatures, 0, sizeof(extractedSignatures));
 
   if (!fp) {
     fprintf(stderr, "ERROR: Invalid file pointer passed.\n");
     return CryptoX_Error;
   }
-  
-  /* To protect against invalid MAR files, we assumes that the MAR file 
+
+  /* To protect against invalid MAR files, we assumes that the MAR file
      size is less than or equal to MAX_SIZE_OF_MAR_FILE. */
   if (fseeko(fp, 0, SEEK_END)) {
     fprintf(stderr, "ERROR: Could not seek to the end of the MAR file.\n");
     return CryptoX_Error;
   }
   if (ftello(fp) > MAX_SIZE_OF_MAR_FILE) {
     fprintf(stderr, "ERROR: MAR file is too large to be verified.\n");
     return CryptoX_Error;
@@ -241,17 +241,17 @@ mar_extract_and_verify_signatures_fp(FIL
 
   for (i = 0; i < signatureCount; i++) {
     /* Get the signature algorithm ID */
     if (fread(&signatureAlgorithmIDs[i], sizeof(uint32_t), 1, fp) != 1) {
       fprintf(stderr, "ERROR: Could not read signatures algorithm ID.\n");
       return CryptoX_Error;
     }
     signatureAlgorithmIDs[i] = ntohl(signatureAlgorithmIDs[i]);
-  
+
     if (fread(&signatureLen, sizeof(uint32_t), 1, fp) != 1) {
       fprintf(stderr, "ERROR: Could not read signatures length.\n");
       return CryptoX_Error;
     }
     signatureLen = ntohl(signatureLen);
 
     /* To protected against invalid input make sure the signature length
        isn't too big. */
@@ -314,17 +314,17 @@ mar_extract_and_verify_signatures_fp(FIL
 }
 
 /**
  * Verifies a MAR file by verifying each signature with the corresponding
  * certificate. That is, the first signature will be verified using the first
  * certificate given, the second signature will be verified using the second
  * certificate given, etc. The signature count must exactly match the number of
  * certificates given, and all signature verifications must succeed.
- * 
+ *
  * @param  fp                   An opened MAR file handle
  * @param  provider             A library provider
  * @param  keys                 A pointer to the first element in an
  *                              array of keys.
  * @param  extractedSignatures  Pointer to the first element in an array
  *                              of extracted signatures.
  * @param  signatureCount       The number of signatures in the MAR file
  * @param numVerified           Out parameter which will be filled with
@@ -354,17 +354,17 @@ mar_verify_signatures_for_fp(FILE *fp,
     fprintf(stderr, "ERROR: Invalid parameter specified.\n");
     goto failure;
   }
 
   *numVerified = 0;
 
   /* This function is only called when we have at least one signature,
      but to protected against future people who call this function we
-     make sure a non zero value is passed in. 
+     make sure a non zero value is passed in.
    */
   if (!signatureCount) {
     fprintf(stderr, "ERROR: There must be at least one signature.\n");
     goto failure;
   }
 
   for (i = 0; i < signatureCount; i++) {
     if (CryptoX_Failed(CryptoX_VerifyBegin(provider,
@@ -376,43 +376,43 @@ mar_verify_signatures_for_fp(FILE *fp,
 
   /* Skip to the start of the file */
   if (fseeko(fp, 0, SEEK_SET)) {
     fprintf(stderr, "ERROR: Could not seek to start of the file\n");
     goto failure;
   }
 
   /* Bytes 0-3: MAR1
-     Bytes 4-7: index offset 
+     Bytes 4-7: index offset
      Bytes 8-15: size of entire MAR
    */
-  if (CryptoX_Failed(ReadAndUpdateVerifyContext(fp, buf, 
+  if (CryptoX_Failed(ReadAndUpdateVerifyContext(fp, buf,
                                                 SIGNATURE_BLOCK_OFFSET +
                                                 sizeof(uint32_t),
                                                 signatureHandles,
                                                 signatureCount,
                                                 "signature block"))) {
     goto failure;
   }
 
   /* Read the signature block */
   for (i = 0; i < signatureCount; i++) {
     /* Get the signature algorithm ID */
     if (CryptoX_Failed(ReadAndUpdateVerifyContext(fp,
-                                                  &buf, 
+                                                  &buf,
                                                   sizeof(uint32_t),
                                                   signatureHandles,
                                                   signatureCount,
                                                   "signature algorithm ID"))) {
       goto failure;
     }
 
-    if (CryptoX_Failed(ReadAndUpdateVerifyContext(fp, 
+    if (CryptoX_Failed(ReadAndUpdateVerifyContext(fp,
                                                   &signatureLengths[i],
-                                                  sizeof(uint32_t), 
+                                                  sizeof(uint32_t),
                                                   signatureHandles,
                                                   signatureCount,
                                                   "signature length"))) {
       goto failure;
     }
     signatureLengths[i] = ntohl(signatureLengths[i]);
     if (signatureLengths[i] > MAX_SIGNATURE_LENGTH) {
       fprintf(stderr, "ERROR: Embedded signature length is too large.\n");
--- a/modules/libpref/test/gtest/Parser.cpp
+++ b/modules/libpref/test/gtest/Parser.cpp
@@ -51,18 +51,18 @@ user_pref("string", "value");
   );
 
   // Totally empty input.
   DEFAULT("",
     ""
   );
 
   // Whitespace-only input.
-  DEFAULT(R"(   
-		
+  DEFAULT(R"(
+
     )" "\v \t \v \f",
     ""
   );
 
   //-------------------------------------------------------------------------
   // All the lexing errors. (To be pedantic, some of the integer literal
   // overflows are triggered in the parser, but put them all here so they're all
   // in the one spot.)
--- a/netwerk/base/nsURLParsers.cpp
+++ b/netwerk/base/nsURLParsers.cpp
@@ -478,17 +478,16 @@ nsAuthURLParser::ParseAuthority(const ch
         if (port)
             *port = -1;
         return NS_OK;
     }
 
     // search backwards for @
     const char *p = auth + authLen - 1;
     for (; (*p != '@') && (p > auth); --p) {
-        continue; 
     }
     if ( *p == '@' ) {
         // auth = <user-info@server-info>
         rv = ParseUserInfo(auth, p - auth,
                            usernamePos, usernameLen,
                            passwordPos, passwordLen);
         if (NS_FAILED(rv)) return rv;
         rv = ParseServerInfo(p + 1, authLen - (p - auth + 1),
--- a/netwerk/ipc/NeckoMessageUtils.h
+++ b/netwerk/ipc/NeckoMessageUtils.h
@@ -27,17 +27,17 @@ struct Permission
   uint32_t capability, expireType;
   int64_t expireTime;
 
   Permission()
     : capability(0)
     , expireType(0)
     , expireTime(0)
   {}
-  
+
   Permission(const nsCString& aOrigin,
              const nsCString& aType,
              const uint32_t aCapability,
              const uint32_t aExpireType,
              const int64_t aExpireTime) : origin(aOrigin),
                                           type(aType),
                                           capability(aCapability),
                                           expireType(aExpireType),
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -717,17 +717,17 @@ nsHttpChannel::CheckFastBlocked()
 
     if (!StaticPrefs::browser_contentblocking_enabled() ||
         !sIsFastBlockEnabled ||
         IsContentPolicyTypeWhitelistedForFastBlock(mLoadInfo) ||
         // If the user has interacted with the document, we disable fastblock.
         (mLoadInfo && mLoadInfo->GetDocumentHasUserInteracted())) {
 
         LOG(("FastBlock passed (invalid) [this=%p]\n", this));
-        
+
         return false;
     }
 
     TimeDuration duration = TimeStamp::NowLoRes() - timestamp;
     bool isFastBlocking = duration.ToMilliseconds() >= sFastBlockTimeout;
 
     if (isFastBlocking && mLoadInfo) {
         MOZ_ALWAYS_SUCCEEDS(mLoadInfo->SetIsTrackerBlocked(true));
--- a/netwerk/protocol/http/nsHttpTransaction.cpp
+++ b/netwerk/protocol/http/nsHttpTransaction.cpp
@@ -877,17 +877,17 @@ nsHttpTransaction::WritePipeSegment(nsIO
 
 bool nsHttpTransaction::ShouldThrottle()
 {
     if (mClassOfService & nsIClassOfService::DontThrottle) {
         // We deliberately don't touch the throttling window here since
         // DontThrottle requests are expected to be long-standing media
         // streams and would just unnecessarily block running downloads.
         // If we want to ballance bandwidth for media responses against
-        // running downloads, we need to find something smarter like 
+        // running downloads, we need to find something smarter like
         // changing the suspend/resume throttling intervals at-runtime.
         return false;
     }
 
     if (!gHttpHandler->ConnMgr()->ShouldThrottle(this)) {
         // We are not obligated to throttle
         return false;
     }
--- a/xpcom/string/nsReadableUtils.h
+++ b/xpcom/string/nsReadableUtils.h
@@ -323,17 +323,17 @@ AppendUTF16toUTF8(mozilla::Span<const ch
   }
 }
 
 // UTF-16 to Latin1
 // If all code points in the input are below U+0100, represents each scalar
 // value as an unsigned byte. (This is not windows-1252!) If there are code
 // points above U+00FF, memory-safely produces garbage and will likely start
 // asserting in future debug builds. The nature of the garbage may differ
-// based on CPU architecture and must not be relied upon. The names say 
+// based on CPU architecture and must not be relied upon. The names say
 // "ASCII" instead of "Latin1" for legacy reasons.
 
 inline MOZ_MUST_USE bool
 LossyCopyUTF16toASCII(mozilla::Span<const char16_t> aSource,
                       nsACString& aDest,
                       const mozilla::fallible_t&)
 {
   return nscstring_fallible_append_utf16_to_latin1_lossy_impl(