Bug 1405210 - Part 3: Apply clang-format to added print dialog widget code. r=jimm
authorMantaroh Yoshinaga <mantaroh@gmail.com>
Thu, 19 Oct 2017 11:04:50 +0900
changeset 683859 fbdb84f3a8c4bebf0b179d395c8d400f2358067e
parent 683858 bbc8f61facefdea8ac6b8a12201bf59d15661ac0
child 683860 f0832773e45106bccf83d35fec16066670e5823a
push id85474
push userbmo:emilio@crisal.io
push dateFri, 20 Oct 2017 10:02:12 +0000
reviewersjimm
bugs1405210
milestone58.0a1
Bug 1405210 - Part 3: Apply clang-format to added print dialog widget code. r=jimm ./mach clang-format --path widget/windows/nsPrintDialog* MozReview-Commit-ID: T1WuQ41GAN
widget/windows/nsPrintDialogUtil.cpp
widget/windows/nsPrintDialogUtil.h
widget/windows/nsPrintDialogWin.cpp
widget/windows/nsPrintDialogWin.h
--- a/widget/windows/nsPrintDialogUtil.cpp
+++ b/widget/windows/nsPrintDialogUtil.cpp
@@ -55,59 +55,59 @@ WIN_LIBS=                               
 // This is for extending the dialog
 #include <dlgs.h>
 
 #include "nsWindowsHelpers.h"
 #include "WinUtils.h"
 
 // Default labels for the radio buttons
 static const wchar_t* kAsLaidOutOnScreenStr = L"As &laid out on the screen";
-static const wchar_t* kTheSelectedFrameStr  = L"The selected &frame";
-static const wchar_t* kEachFrameSeparately  = L"&Each frame separately";
-
+static const wchar_t* kTheSelectedFrameStr = L"The selected &frame";
+static const wchar_t* kEachFrameSeparately = L"&Each frame separately";
 
 //-----------------------------------------------
 // Global Data
 //-----------------------------------------------
 // Identifies which new radio btn was cliked on
 static UINT gFrameSelectedRadioBtn = 0;
 
 // Indicates whether the native print dialog was successfully extended
-static bool gDialogWasExtended     = false;
+static bool gDialogWasExtended = false;
 
 #define PRINTDLG_PROPERTIES "chrome://global/locale/printdialog.properties"
 
 static HWND gParentWnd = nullptr;
 
 //----------------------------------------------------------------------------------
 // Return localized bundle for resource strings
 static nsresult
-GetLocalizedBundle(const char * aPropFileName, nsIStringBundle** aStrBundle)
+GetLocalizedBundle(const char* aPropFileName, nsIStringBundle** aStrBundle)
 {
   NS_ENSURE_ARG_POINTER(aPropFileName);
   NS_ENSURE_ARG_POINTER(aStrBundle);
 
   nsresult rv;
   nsCOMPtr<nsIStringBundle> bundle;
 
-
   // Create bundle
   nsCOMPtr<nsIStringBundleService> stringService =
     do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
   if (NS_SUCCEEDED(rv) && stringService) {
     rv = stringService->CreateBundle(aPropFileName, aStrBundle);
   }
 
   return rv;
 }
 
 //--------------------------------------------------------
 // Return localized string
 static nsresult
-GetLocalizedString(nsIStringBundle* aStrBundle, const char* aKey, nsString& oVal)
+GetLocalizedString(nsIStringBundle* aStrBundle,
+                   const char* aKey,
+                   nsString& oVal)
 {
   NS_ENSURE_ARG_POINTER(aStrBundle);
   NS_ENSURE_ARG_POINTER(aKey);
 
   // Determine default label from string bundle
   nsAutoString valUni;
   nsresult rv = aStrBundle->GetStringFromName(aKey, valUni);
   if (NS_SUCCEEDED(rv)) {
@@ -115,169 +115,183 @@ GetLocalizedString(nsIStringBundle* aStr
   } else {
     oVal.Truncate();
   }
   return rv;
 }
 
 //--------------------------------------------------------
 // Set a multi-byte string in the control
-static void SetTextOnWnd(HWND aControl, const nsAString& aStr)
+static void
+SetTextOnWnd(HWND aControl, const nsAString& aStr)
 {
   ::SetWindowTextW(aControl,
                    reinterpret_cast<const wchar_t*>(aStr.BeginReading()));
 }
 
 //--------------------------------------------------------
 // Will get the control and localized string by "key"
-static void SetText(HWND             aParent,
-                    UINT             aId,
-                    nsIStringBundle* aStrBundle,
-                    const char*      aKey)
+static void
+SetText(HWND aParent, UINT aId, nsIStringBundle* aStrBundle, const char* aKey)
 {
-  HWND wnd = GetDlgItem (aParent, aId);
+  HWND wnd = GetDlgItem(aParent, aId);
   if (!wnd) {
     return;
   }
   nsAutoString str;
   nsresult rv = GetLocalizedString(aStrBundle, aKey, str);
   if (NS_SUCCEEDED(rv)) {
     SetTextOnWnd(wnd, str);
   }
 }
 
 //--------------------------------------------------------
-static void SetRadio(HWND         aParent,
-                     UINT         aId,
-                     bool         aIsSet,
-                     bool         isEnabled = true)
+static void
+SetRadio(HWND aParent, UINT aId, bool aIsSet, bool isEnabled = true)
 {
-  HWND wnd = ::GetDlgItem (aParent, aId);
+  HWND wnd = ::GetDlgItem(aParent, aId);
   if (!wnd) {
     return;
   }
   if (!isEnabled) {
     ::EnableWindow(wnd, FALSE);
     return;
   }
   ::EnableWindow(wnd, TRUE);
   ::SendMessage(wnd, BM_SETCHECK, (WPARAM)aIsSet, (LPARAM)0);
 }
 
 //--------------------------------------------------------
-static void SetRadioOfGroup(HWND aDlg, int aRadId)
+static void
+SetRadioOfGroup(HWND aDlg, int aRadId)
 {
-  int radioIds[] = {rad4, rad5, rad6};
+  int radioIds[] = { rad4, rad5, rad6 };
   int numRads = 3;
 
-  for (int i=0;i<numRads;i++) {
+  for (int i = 0; i < numRads; i++) {
     HWND radWnd = ::GetDlgItem(aDlg, radioIds[i]);
     if (radWnd != nullptr) {
-      ::SendMessage(radWnd, BM_SETCHECK, (WPARAM)(radioIds[i] == aRadId), (LPARAM)0);
+      ::SendMessage(
+        radWnd, BM_SETCHECK, (WPARAM)(radioIds[i] == aRadId), (LPARAM)0);
     }
   }
 }
 
 //--------------------------------------------------------
-typedef struct {
-  const char * mKeyStr;
-  long   mKeyId;
+typedef struct
+{
+  const char* mKeyStr;
+  long mKeyId;
 } PropKeyInfo;
 
 // These are the control ids used in the dialog and
 // defined by MS-Windows in commdlg.h
-static PropKeyInfo gAllPropKeys[] = {
-    {"printFramesTitleWindows", grp3},
-    {"asLaidOutWindows", rad4},
-    {"selectedFrameWindows", rad5},
-    {"separateFramesWindows", rad6},
-    {nullptr, 0}};
+static PropKeyInfo gAllPropKeys[] = { { "printFramesTitleWindows", grp3 },
+                                      { "asLaidOutWindows", rad4 },
+                                      { "selectedFrameWindows", rad5 },
+                                      { "separateFramesWindows", rad6 },
+                                      { nullptr, 0 } };
 
 //--------------------------------------------------------
 //--------------------------------------------------------
 //--------------------------------------------------------
 //--------------------------------------------------------
 // Get the absolute coords of the child windows relative
 // to its parent window
-static void GetLocalRect(HWND aWnd, RECT& aRect, HWND aParent)
+static void
+GetLocalRect(HWND aWnd, RECT& aRect, HWND aParent)
 {
   ::GetWindowRect(aWnd, &aRect);
 
   // MapWindowPoints converts screen coordinates to client coordinates.
   // It works correctly in both left-to-right and right-to-left windows.
   ::MapWindowPoints(nullptr, aParent, (LPPOINT)&aRect, 2);
 }
 
 //--------------------------------------------------------
 // Show or Hide the control
-static void Show(HWND aWnd, bool bState)
+static void
+Show(HWND aWnd, bool bState)
 {
   if (aWnd) {
-    ::ShowWindow(aWnd, bState?SW_SHOW:SW_HIDE);
+    ::ShowWindow(aWnd, bState ? SW_SHOW : SW_HIDE);
   }
 }
 
 //--------------------------------------------------------
 // Create a child window "control"
-static HWND CreateControl(LPCWSTR          aType,
-                          DWORD            aStyle,
-                          HINSTANCE        aHInst,
-                          HWND             aHdlg,
-                          int              aId,
-                          LPCWSTR           aStr,
-                          const nsIntRect& aRect)
+static HWND
+CreateControl(LPCWSTR aType,
+              DWORD aStyle,
+              HINSTANCE aHInst,
+              HWND aHdlg,
+              int aId,
+              LPCWSTR aStr,
+              const nsIntRect& aRect)
 {
-  HWND hWnd = ::CreateWindowW(aType, aStr,
+  HWND hWnd = ::CreateWindowW(aType,
+                              aStr,
                               WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | aStyle,
-                              aRect.x, aRect.y, aRect.width, aRect.height,
-                              (HWND)aHdlg, (HMENU)(intptr_t)aId,
-                              aHInst, nullptr);
-  if (hWnd == nullptr) return nullptr;
+                              aRect.x,
+                              aRect.y,
+                              aRect.width,
+                              aRect.height,
+                              (HWND)aHdlg,
+                              (HMENU)(intptr_t)aId,
+                              aHInst,
+                              nullptr);
+  if (hWnd == nullptr)
+    return nullptr;
 
   // get the native font for the dialog and
   // set it into the new control
   HFONT hFont = (HFONT)::SendMessage(aHdlg, WM_GETFONT, (WPARAM)0, (LPARAM)0);
   if (hFont != nullptr) {
-    ::SendMessage(hWnd, WM_SETFONT, (WPARAM) hFont, (LPARAM)0);
+    ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, (LPARAM)0);
   }
   return hWnd;
 }
 
 //--------------------------------------------------------
 // Create a Radio Button
-static HWND CreateRadioBtn(HINSTANCE        aHInst,
-                           HWND             aHdlg,
-                           int              aId,
-                           LPCWSTR          aStr,
-                           const nsIntRect& aRect)
+static HWND
+CreateRadioBtn(HINSTANCE aHInst,
+               HWND aHdlg,
+               int aId,
+               LPCWSTR aStr,
+               const nsIntRect& aRect)
 {
-  return CreateControl(L"BUTTON", BS_RADIOBUTTON, aHInst, aHdlg, aId, aStr, aRect);
+  return CreateControl(
+    L"BUTTON", BS_RADIOBUTTON, aHInst, aHdlg, aId, aStr, aRect);
 }
 
 //--------------------------------------------------------
 // Create a Group Box
-static HWND CreateGroupBox(HINSTANCE        aHInst,
-                           HWND             aHdlg,
-                           int              aId,
-                           LPCWSTR          aStr,
-                           const nsIntRect& aRect)
+static HWND
+CreateGroupBox(HINSTANCE aHInst,
+               HWND aHdlg,
+               int aId,
+               LPCWSTR aStr,
+               const nsIntRect& aRect)
 {
   return CreateControl(L"BUTTON", BS_GROUPBOX, aHInst, aHdlg, aId, aStr, aRect);
 }
 
 //--------------------------------------------------------
 // Localizes and initializes the radio buttons and group
-static void InitializeExtendedDialog(HWND hdlg, int16_t aHowToEnableFrameUI)
+static void
+InitializeExtendedDialog(HWND hdlg, int16_t aHowToEnableFrameUI)
 {
   MOZ_ASSERT(aHowToEnableFrameUI != nsIPrintSettings::kFrameEnableNone,
              "should not be called");
 
   // Localize the new controls in the print dialog
   nsCOMPtr<nsIStringBundle> strBundle;
-  if (NS_SUCCEEDED(GetLocalizedBundle(PRINTDLG_PROPERTIES, getter_AddRefs(strBundle)))) {
+  if (NS_SUCCEEDED(
+        GetLocalizedBundle(PRINTDLG_PROPERTIES, getter_AddRefs(strBundle)))) {
     int32_t i = 0;
     while (gAllPropKeys[i].mKeyStr != nullptr) {
       SetText(hdlg, gAllPropKeys[i].mKeyId, strBundle, gAllPropKeys[i].mKeyStr);
       i++;
     }
   }
 
   // Set up radio buttons
@@ -292,116 +306,130 @@ static void InitializeExtendedDialog(HWN
     SetRadio(hdlg, rad4, false);
     SetRadio(hdlg, rad5, false, false);
     SetRadio(hdlg, rad6, true);
     // set default so user doesn't have to actually press on it
     gFrameSelectedRadioBtn = rad6;
   }
 }
 
-
 //--------------------------------------------------------
 // Special Hook Procedure for handling the print dialog messages
-static UINT CALLBACK PrintHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
+static UINT CALLBACK
+PrintHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
 {
 
   if (uiMsg == WM_COMMAND) {
     UINT id = LOWORD(wParam);
     if (id == rad4 || id == rad5 || id == rad6) {
       gFrameSelectedRadioBtn = id;
       SetRadioOfGroup(hdlg, id);
     }
 
   } else if (uiMsg == WM_INITDIALOG) {
-    PRINTDLG * printDlg = (PRINTDLG *)lParam;
-    if (printDlg == nullptr) return 0L;
+    PRINTDLG* printDlg = (PRINTDLG*)lParam;
+    if (printDlg == nullptr)
+      return 0L;
 
     int16_t howToEnableFrameUI = (int16_t)printDlg->lCustData;
     // don't add frame options if they would be disabled anyway
     // because there are no frames
     if (howToEnableFrameUI == nsIPrintSettings::kFrameEnableNone)
       return TRUE;
 
     HINSTANCE hInst = (HINSTANCE)::GetWindowLongPtr(hdlg, GWLP_HINSTANCE);
-    if (hInst == nullptr) return 0L;
+    if (hInst == nullptr)
+      return 0L;
 
     // Start by getting the local rects of several of the controls
     // so we can calculate where the new controls are
     HWND wnd = ::GetDlgItem(hdlg, grp1);
-    if (wnd == nullptr) return 0L;
+    if (wnd == nullptr)
+      return 0L;
     RECT dlgRect;
     GetLocalRect(wnd, dlgRect, hdlg);
 
     wnd = ::GetDlgItem(hdlg, rad1); // this is the top control "All"
-    if (wnd == nullptr) return 0L;
+    if (wnd == nullptr)
+      return 0L;
     RECT rad1Rect;
     GetLocalRect(wnd, rad1Rect, hdlg);
 
     wnd = ::GetDlgItem(hdlg, rad2); // this is the bottom control "Selection"
-    if (wnd == nullptr) return 0L;
+    if (wnd == nullptr)
+      return 0L;
     RECT rad2Rect;
     GetLocalRect(wnd, rad2Rect, hdlg);
 
     wnd = ::GetDlgItem(hdlg, rad3); // this is the middle control "Pages"
-    if (wnd == nullptr) return 0L;
+    if (wnd == nullptr)
+      return 0L;
     RECT rad3Rect;
     GetLocalRect(wnd, rad3Rect, hdlg);
 
     HWND okWnd = ::GetDlgItem(hdlg, IDOK);
-    if (okWnd == nullptr) return 0L;
+    if (okWnd == nullptr)
+      return 0L;
     RECT okRect;
     GetLocalRect(okWnd, okRect, hdlg);
 
     wnd = ::GetDlgItem(hdlg, grp4); // this is the "Print range" groupbox
-    if (wnd == nullptr) return 0L;
+    if (wnd == nullptr)
+      return 0L;
     RECT prtRect;
     GetLocalRect(wnd, prtRect, hdlg);
 
-
     // calculate various different "gaps" for layout purposes
 
-    int rbGap     = rad3Rect.top - rad1Rect.bottom;     // gap between radiobtns
-    int grpBotGap = dlgRect.bottom - rad2Rect.bottom;   // gap from bottom rb to bottom of grpbox
-    int grpGap    = dlgRect.top - prtRect.bottom ;      // gap between group boxes
-    int top       = dlgRect.bottom + grpGap;
-    int radHgt    = rad1Rect.bottom - rad1Rect.top + 1; // top of new group box
-    int y         = top+(rad1Rect.top-dlgRect.top);     // starting pos of first radio
-    int rbWidth   = dlgRect.right - rad1Rect.left - 5;  // measure from rb left to the edge of the groupbox
-                                                        // (5 is arbitrary)
+    int rbGap = rad3Rect.top - rad1Rect.bottom; // gap between radiobtns
+    int grpBotGap = dlgRect.bottom -
+                    rad2Rect.bottom; // gap from bottom rb to bottom of grpbox
+    int grpGap = dlgRect.top - prtRect.bottom; // gap between group boxes
+    int top = dlgRect.bottom + grpGap;
+    int radHgt = rad1Rect.bottom - rad1Rect.top + 1; // top of new group box
+    int y = top + (rad1Rect.top - dlgRect.top); // starting pos of first radio
+    int rbWidth = dlgRect.right - rad1Rect.left -
+                  5; // measure from rb left to the edge of the groupbox
+                     // (5 is arbitrary)
     nsIntRect rect;
 
     // Create and position the radio buttons
     //
     // If any one control cannot be created then
     // hide the others and bail out
     //
-    rect.SetRect(rad1Rect.left, y, rbWidth,radHgt);
-    HWND rad4Wnd = CreateRadioBtn(hInst, hdlg, rad4, kAsLaidOutOnScreenStr, rect);
-    if (rad4Wnd == nullptr) return 0L;
+    rect.SetRect(rad1Rect.left, y, rbWidth, radHgt);
+    HWND rad4Wnd =
+      CreateRadioBtn(hInst, hdlg, rad4, kAsLaidOutOnScreenStr, rect);
+    if (rad4Wnd == nullptr)
+      return 0L;
     y += radHgt + rbGap;
 
     rect.SetRect(rad1Rect.left, y, rbWidth, radHgt);
-    HWND rad5Wnd = CreateRadioBtn(hInst, hdlg, rad5, kTheSelectedFrameStr, rect);
+    HWND rad5Wnd =
+      CreateRadioBtn(hInst, hdlg, rad5, kTheSelectedFrameStr, rect);
     if (rad5Wnd == nullptr) {
       Show(rad4Wnd, FALSE); // hide
       return 0L;
     }
     y += radHgt + rbGap;
 
     rect.SetRect(rad1Rect.left, y, rbWidth, radHgt);
-    HWND rad6Wnd = CreateRadioBtn(hInst, hdlg, rad6, kEachFrameSeparately, rect);
+    HWND rad6Wnd =
+      CreateRadioBtn(hInst, hdlg, rad6, kEachFrameSeparately, rect);
     if (rad6Wnd == nullptr) {
       Show(rad4Wnd, FALSE); // hide
       Show(rad5Wnd, FALSE); // hide
       return 0L;
     }
     y += radHgt + grpBotGap;
 
     // Create and position the group box
-    rect.SetRect (dlgRect.left, top, dlgRect.right-dlgRect.left+1, y-top+1);
+    rect.SetRect(
+      dlgRect.left, top, dlgRect.right - dlgRect.left + 1, y - top + 1);
     HWND grpBoxWnd = CreateGroupBox(hInst, hdlg, grp3, L"Print Frame", rect);
     if (grpBoxWnd == nullptr) {
       Show(rad4Wnd, FALSE); // hide
       Show(rad5Wnd, FALSE); // hide
       Show(rad6Wnd, FALSE); // hide
       return 0L;
     }
 
@@ -409,38 +437,55 @@ static UINT CALLBACK PrintHookProc(HWND 
     // then figure its gap from the old grpbx to the bottom
     // then size the dlg
     RECT pr, cr;
     ::GetWindowRect(hdlg, &pr);
     ::GetClientRect(hdlg, &cr);
 
     int dlgHgt = (cr.bottom - cr.top) + 1;
     int bottomGap = dlgHgt - okRect.bottom;
-    pr.bottom += (dlgRect.bottom-dlgRect.top) + grpGap + 1 - (dlgHgt-dlgRect.bottom) + bottomGap;
+    pr.bottom += (dlgRect.bottom - dlgRect.top) + grpGap + 1 -
+                 (dlgHgt - dlgRect.bottom) + bottomGap;
 
-    ::SetWindowPos(hdlg, nullptr, pr.left, pr.top, pr.right-pr.left+1, pr.bottom-pr.top+1,
-                   SWP_NOMOVE|SWP_NOREDRAW|SWP_NOZORDER);
+    ::SetWindowPos(hdlg,
+                   nullptr,
+                   pr.left,
+                   pr.top,
+                   pr.right - pr.left + 1,
+                   pr.bottom - pr.top + 1,
+                   SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
 
     // figure out the new height of the dialog
     ::GetClientRect(hdlg, &cr);
     dlgHgt = (cr.bottom - cr.top) + 1;
 
     // Reposition the OK and Cancel btns
     int okHgt = okRect.bottom - okRect.top + 1;
-    ::SetWindowPos(okWnd, nullptr, okRect.left, dlgHgt-bottomGap-okHgt, 0, 0,
-                   SWP_NOSIZE|SWP_NOREDRAW|SWP_NOZORDER);
+    ::SetWindowPos(okWnd,
+                   nullptr,
+                   okRect.left,
+                   dlgHgt - bottomGap - okHgt,
+                   0,
+                   0,
+                   SWP_NOSIZE | SWP_NOREDRAW | SWP_NOZORDER);
 
     HWND cancelWnd = ::GetDlgItem(hdlg, IDCANCEL);
-    if (cancelWnd == nullptr) return 0L;
+    if (cancelWnd == nullptr)
+      return 0L;
 
     RECT cancelRect;
     GetLocalRect(cancelWnd, cancelRect, hdlg);
     int cancelHgt = cancelRect.bottom - cancelRect.top + 1;
-    ::SetWindowPos(cancelWnd, nullptr, cancelRect.left, dlgHgt-bottomGap-cancelHgt, 0, 0,
-                   SWP_NOSIZE|SWP_NOREDRAW|SWP_NOZORDER);
+    ::SetWindowPos(cancelWnd,
+                   nullptr,
+                   cancelRect.left,
+                   dlgHgt - bottomGap - cancelHgt,
+                   0,
+                   0,
+                   SWP_NOSIZE | SWP_NOREDRAW | SWP_NOZORDER);
 
     // localize and initialize the groupbox and radiobuttons
     InitializeExtendedDialog(hdlg, howToEnableFrameUI);
 
     // Looks like we were able to extend the dialog
     gDialogWasExtended = true;
     return TRUE;
   }
@@ -455,90 +500,98 @@ static UINT CALLBACK PrintHookProc(HWND 
 //   This function assumes that aPrintName has already been converted from
 //   unicode
 //
 static nsReturnRef<nsHGLOBAL>
 CreateGlobalDevModeAndInit(const nsString& aPrintName, nsIPrintSettings* aPS)
 {
   nsHPRINTER hPrinter = nullptr;
   // const cast kludge for silly Win32 api's
-  LPWSTR printName = const_cast<wchar_t*>(static_cast<const wchar_t*>(aPrintName.get()));
+  LPWSTR printName =
+    const_cast<wchar_t*>(static_cast<const wchar_t*>(aPrintName.get()));
   BOOL status = ::OpenPrinterW(printName, &hPrinter, nullptr);
   if (!status) {
     return nsReturnRef<nsHGLOBAL>();
   }
 
   // Make sure hPrinter is closed on all paths
   nsAutoPrinter autoPrinter(hPrinter);
 
   // Get the buffer size
-  LONG needed = ::DocumentPropertiesW(gParentWnd, hPrinter, printName, nullptr,
-                                      nullptr, 0);
+  LONG needed =
+    ::DocumentPropertiesW(gParentWnd, hPrinter, printName, nullptr, nullptr, 0);
   if (needed < 0) {
     return nsReturnRef<nsHGLOBAL>();
   }
 
   // Allocate a buffer of the correct size.
-  nsAutoDevMode newDevMode((LPDEVMODEW)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY,
-                                                   needed));
+  nsAutoDevMode newDevMode(
+    (LPDEVMODEW)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, needed));
   if (!newDevMode) {
     return nsReturnRef<nsHGLOBAL>();
   }
 
   nsHGLOBAL hDevMode = ::GlobalAlloc(GHND, needed);
   nsAutoGlobalMem globalDevMode(hDevMode);
   if (!hDevMode) {
     return nsReturnRef<nsHGLOBAL>();
   }
 
-  LONG ret = ::DocumentPropertiesW(gParentWnd, hPrinter, printName, newDevMode,
-                                   nullptr, DM_OUT_BUFFER);
+  LONG ret = ::DocumentPropertiesW(
+    gParentWnd, hPrinter, printName, newDevMode, nullptr, DM_OUT_BUFFER);
   if (ret != IDOK) {
     return nsReturnRef<nsHGLOBAL>();
   }
 
   // Lock memory and copy contents from DEVMODE (current printer)
   // to Global Memory DEVMODE
-  LPDEVMODEW devMode = (DEVMODEW *)::GlobalLock(hDevMode);
+  LPDEVMODEW devMode = (DEVMODEW*)::GlobalLock(hDevMode);
   if (!devMode) {
     return nsReturnRef<nsHGLOBAL>();
   }
 
   memcpy(devMode, newDevMode.get(), needed);
   // Initialize values from the PrintSettings
   nsCOMPtr<nsIPrintSettingsWin> psWin = do_QueryInterface(aPS);
   MOZ_ASSERT(psWin);
   psWin->CopyToNative(devMode);
 
   // Sets back the changes we made to the DevMode into the Printer Driver
-  ret = ::DocumentPropertiesW(gParentWnd, hPrinter, printName, devMode, devMode,
+  ret = ::DocumentPropertiesW(gParentWnd,
+                              hPrinter,
+                              printName,
+                              devMode,
+                              devMode,
                               DM_IN_BUFFER | DM_OUT_BUFFER);
   if (ret != IDOK) {
     ::GlobalUnlock(hDevMode);
     return nsReturnRef<nsHGLOBAL>();
   }
 
   ::GlobalUnlock(hDevMode);
 
   return globalDevMode.out();
 }
 
 //------------------------------------------------------------------
 // helper
-static void GetDefaultPrinterNameFromGlobalPrinters(nsAString &printerName)
+static void
+GetDefaultPrinterNameFromGlobalPrinters(nsAString& printerName)
 {
-  nsCOMPtr<nsIPrinterEnumerator> prtEnum = do_GetService("@mozilla.org/gfx/printerenumerator;1");
+  nsCOMPtr<nsIPrinterEnumerator> prtEnum =
+    do_GetService("@mozilla.org/gfx/printerenumerator;1");
   if (prtEnum) {
     prtEnum->GetDefaultPrinterName(printerName);
   }
 }
 
 // Determine whether we have a completely native dialog
 // or whether we cshould extend it
-static bool ShouldExtendPrintDialog()
+static bool
+ShouldExtendPrintDialog()
 {
   nsresult rv;
   nsCOMPtr<nsIPrefService> prefs =
     do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, true);
   nsCOMPtr<nsIPrefBranch> prefBranch;
   rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch));
   NS_ENSURE_SUCCESS(rv, true);
@@ -547,151 +600,153 @@ static bool ShouldExtendPrintDialog()
   rv = prefBranch->GetBoolPref("print.extend_native_print_dialog", &result);
   NS_ENSURE_SUCCESS(rv, true);
   return result;
 }
 
 //------------------------------------------------------------------
 // Displays the native Print Dialog
 static nsresult
-ShowNativePrintDialog(HWND              aHWnd,
-                      nsIPrintSettings* aPrintSettings)
+ShowNativePrintDialog(HWND aHWnd, nsIPrintSettings* aPrintSettings)
 {
   //NS_ENSURE_ARG_POINTER(aHWnd);
   NS_ENSURE_ARG_POINTER(aPrintSettings);
 
-  gDialogWasExtended  = false;
+  gDialogWasExtended = false;
 
   // Get the Print Name to be used
   nsString printerName;
   aPrintSettings->GetPrinterName(printerName);
 
   // If there is no name then use the default printer
   if (printerName.IsEmpty()) {
     GetDefaultPrinterNameFromGlobalPrinters(printerName);
   } else {
     HANDLE hPrinter = nullptr;
-    if(!::OpenPrinterW(const_cast<wchar_t*>(static_cast<const wchar_t*>(printerName.get())),
-                       &hPrinter, nullptr)) {
+    if (!::OpenPrinterW(
+          const_cast<wchar_t*>(static_cast<const wchar_t*>(printerName.get())),
+          &hPrinter,
+          nullptr)) {
       // If the last used printer is not found, we should use default printer.
       GetDefaultPrinterNameFromGlobalPrinters(printerName);
     } else {
       ::ClosePrinter(hPrinter);
     }
   }
 
   // Now create a DEVNAMES struct so the the dialog is initialized correctly.
 
   uint32_t len = printerName.Length();
-  nsHGLOBAL hDevNames = ::GlobalAlloc(GHND, sizeof(wchar_t) * (len + 1)
-                                      + sizeof(DEVNAMES));
+  nsHGLOBAL hDevNames =
+    ::GlobalAlloc(GHND, sizeof(wchar_t) * (len + 1) + sizeof(DEVNAMES));
   nsAutoGlobalMem autoDevNames(hDevNames);
   if (!hDevNames) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   DEVNAMES* pDevNames = (DEVNAMES*)::GlobalLock(hDevNames);
   if (!pDevNames) {
     return NS_ERROR_FAILURE;
   }
-  pDevNames->wDriverOffset = sizeof(DEVNAMES)/sizeof(wchar_t);
-  pDevNames->wDeviceOffset = sizeof(DEVNAMES)/sizeof(wchar_t);
-  pDevNames->wOutputOffset = sizeof(DEVNAMES)/sizeof(wchar_t)+len;
-  pDevNames->wDefault      = 0;
+  pDevNames->wDriverOffset = sizeof(DEVNAMES) / sizeof(wchar_t);
+  pDevNames->wDeviceOffset = sizeof(DEVNAMES) / sizeof(wchar_t);
+  pDevNames->wOutputOffset = sizeof(DEVNAMES) / sizeof(wchar_t) + len;
+  pDevNames->wDefault = 0;
 
-  memcpy(pDevNames+1, printerName.get(), (len + 1) * sizeof(wchar_t));
+  memcpy(pDevNames + 1, printerName.get(), (len + 1) * sizeof(wchar_t));
   ::GlobalUnlock(hDevNames);
 
   // Create a Moveable Memory Object that holds a new DevMode
   // from the Printer Name
   // The PRINTDLG.hDevMode requires that it be a moveable memory object
   // NOTE: autoDevMode is automatically freed when any error occurred
-  nsAutoGlobalMem autoDevMode(CreateGlobalDevModeAndInit(printerName, aPrintSettings));
+  nsAutoGlobalMem autoDevMode(
+    CreateGlobalDevModeAndInit(printerName, aPrintSettings));
 
   // Prepare to Display the Print Dialog
-  PRINTDLGW  prntdlg;
+  PRINTDLGW prntdlg;
   memset(&prntdlg, 0, sizeof(PRINTDLGW));
 
   prntdlg.lStructSize = sizeof(prntdlg);
-  prntdlg.hwndOwner   = aHWnd;
-  prntdlg.hDevMode    = autoDevMode.get();
-  prntdlg.hDevNames   = hDevNames;
-  prntdlg.hDC         = nullptr;
-  prntdlg.Flags       = PD_ALLPAGES | PD_RETURNIC |
-                        PD_USEDEVMODECOPIESANDCOLLATE | PD_COLLATE;
+  prntdlg.hwndOwner = aHWnd;
+  prntdlg.hDevMode = autoDevMode.get();
+  prntdlg.hDevNames = hDevNames;
+  prntdlg.hDC = nullptr;
+  prntdlg.Flags =
+    PD_ALLPAGES | PD_RETURNIC | PD_USEDEVMODECOPIESANDCOLLATE | PD_COLLATE;
 
   // if there is a current selection then enable the "Selection" radio button
   int16_t howToEnableFrameUI = nsIPrintSettings::kFrameEnableNone;
   bool isOn;
   aPrintSettings->GetPrintOptions(nsIPrintSettings::kEnableSelectionRB, &isOn);
   if (!isOn) {
     prntdlg.Flags |= PD_NOSELECTION;
   }
   aPrintSettings->GetHowToEnableFrameUI(&howToEnableFrameUI);
 
   int32_t pg = 1;
   aPrintSettings->GetStartPageRange(&pg);
-  prntdlg.nFromPage           = pg;
+  prntdlg.nFromPage = pg;
 
   aPrintSettings->GetEndPageRange(&pg);
-  prntdlg.nToPage             = pg;
+  prntdlg.nToPage = pg;
 
-  prntdlg.nMinPage            = 1;
-  prntdlg.nMaxPage            = 0xFFFF;
-  prntdlg.nCopies             = 1;
-  prntdlg.lpfnSetupHook       = nullptr;
+  prntdlg.nMinPage = 1;
+  prntdlg.nMaxPage = 0xFFFF;
+  prntdlg.nCopies = 1;
+  prntdlg.lpfnSetupHook = nullptr;
   prntdlg.lpSetupTemplateName = nullptr;
-  prntdlg.hPrintTemplate      = nullptr;
-  prntdlg.hSetupTemplate      = nullptr;
+  prntdlg.hPrintTemplate = nullptr;
+  prntdlg.hSetupTemplate = nullptr;
 
-  prntdlg.hInstance           = nullptr;
+  prntdlg.hInstance = nullptr;
   prntdlg.lpPrintTemplateName = nullptr;
 
   if (!ShouldExtendPrintDialog()) {
-    prntdlg.lCustData         = 0;
-    prntdlg.lpfnPrintHook     = nullptr;
+    prntdlg.lCustData = 0;
+    prntdlg.lpfnPrintHook = nullptr;
   } else {
     // Set up print dialog "hook" procedure for extending the dialog
-    prntdlg.lCustData         = (DWORD)howToEnableFrameUI;
-    prntdlg.lpfnPrintHook     = (LPPRINTHOOKPROC)PrintHookProc;
-    prntdlg.Flags            |= PD_ENABLEPRINTHOOK;
+    prntdlg.lCustData = (DWORD)howToEnableFrameUI;
+    prntdlg.lpfnPrintHook = (LPPRINTHOOKPROC)PrintHookProc;
+    prntdlg.Flags |= PD_ENABLEPRINTHOOK;
   }
 
   BOOL result;
   {
     mozilla::widget::WinUtils::AutoSystemDpiAware dpiAwareness;
     result = ::PrintDlgW(&prntdlg);
   }
 
   if (TRUE == result) {
     // check to make sure we don't have any nullptr pointers
     NS_ENSURE_TRUE(aPrintSettings && prntdlg.hDevMode, NS_ERROR_FAILURE);
 
     if (prntdlg.hDevNames == nullptr) {
       return NS_ERROR_FAILURE;
     }
     // Lock the deviceNames and check for nullptr
-    DEVNAMES *devnames = (DEVNAMES *)::GlobalLock(prntdlg.hDevNames);
+    DEVNAMES* devnames = (DEVNAMES*)::GlobalLock(prntdlg.hDevNames);
     if (devnames == nullptr) {
       return NS_ERROR_FAILURE;
     }
 
-    char16_t* device = &(((char16_t *)devnames)[devnames->wDeviceOffset]);
-    char16_t* driver = &(((char16_t *)devnames)[devnames->wDriverOffset]);
+    char16_t* device = &(((char16_t*)devnames)[devnames->wDeviceOffset]);
+    char16_t* driver = &(((char16_t*)devnames)[devnames->wDriverOffset]);
 
     // Check to see if the "Print To File" control is checked
     // then take the name from devNames and set it in the PrintSettings
     //
     // NOTE:
     // As per Microsoft SDK documentation the returned value offset from
     // devnames->wOutputOffset is either "FILE:" or nullptr
     // if the "Print To File" checkbox is checked it MUST be "FILE:"
     // We assert as an extra safety check.
     if (prntdlg.Flags & PD_PRINTTOFILE) {
-      char16ptr_t fileName = &(((wchar_t *)devnames)[devnames->wOutputOffset]);
+      char16ptr_t fileName = &(((wchar_t*)devnames)[devnames->wOutputOffset]);
       NS_ASSERTION(wcscmp(fileName, L"FILE:") == 0, "FileName must be `FILE:`");
       aPrintSettings->SetToFileName(nsDependentString(fileName));
       aPrintSettings->SetPrintToFile(true);
     } else {
       // clear "print to file" info
       aPrintSettings->SetPrintToFile(false);
       aPrintSettings->SetToFileName(EmptyString());
     }
@@ -701,17 +756,20 @@ ShowNativePrintDialog(HWND              
       return NS_ERROR_FAILURE;
     }
 
     // Setup local Data members
     psWin->SetDeviceName(nsDependentString(device));
     psWin->SetDriverName(nsDependentString(driver));
 
 #if defined(DEBUG_rods) || defined(DEBUG_dcone)
-    wprintf(L"printer: driver %s, device %s  flags: %d\n", driver, device, prntdlg.Flags);
+    wprintf(L"printer: driver %s, device %s  flags: %d\n",
+            driver,
+            device,
+            prntdlg.Flags);
 #endif
     // fill the print options with the info from the dialog
 
     aPrintSettings->SetPrinterName(nsDependentString(device));
 
     if (prntdlg.Flags & PD_SELECTION) {
       aPrintSettings->SetPrintRange(nsIPrintSettings::kRangeSelection);
 
@@ -756,25 +814,25 @@ ShowNativePrintDialog(HWND              
       return NS_ERROR_FAILURE;
     }
     psWin->SetDevMode(devMode); // copies DevMode
     psWin->CopyFromNative(prntdlg.hDC, devMode);
     ::GlobalUnlock(prntdlg.hDevMode);
     ::DeleteDC(prntdlg.hDC);
 
 #if defined(DEBUG_rods) || defined(DEBUG_dcone)
-    bool    printSelection = prntdlg.Flags & PD_SELECTION;
-    bool    printAllPages  = prntdlg.Flags & PD_ALLPAGES;
-    bool    printNumPages  = prntdlg.Flags & PD_PAGENUMS;
-    int32_t fromPageNum    = 0;
-    int32_t toPageNum      = 0;
+    bool printSelection = prntdlg.Flags & PD_SELECTION;
+    bool printAllPages = prntdlg.Flags & PD_ALLPAGES;
+    bool printNumPages = prntdlg.Flags & PD_PAGENUMS;
+    int32_t fromPageNum = 0;
+    int32_t toPageNum = 0;
 
     if (printNumPages) {
       fromPageNum = prntdlg.nFromPage;
-      toPageNum   = prntdlg.nToPage;
+      toPageNum = prntdlg.nToPage;
     }
     if (printSelection) {
       printf("Printing the selection\n");
 
     } else if (printAllPages) {
       printf("Printing all the pages\n");
 
     } else {
@@ -788,17 +846,18 @@ ShowNativePrintDialog(HWND              
     return NS_ERROR_ABORT;
   }
 
   return NS_OK;
 }
 
 //------------------------------------------------------------------
 static void
-PrepareForPrintDialog(nsIWebBrowserPrint* aWebBrowserPrint, nsIPrintSettings* aPS)
+PrepareForPrintDialog(nsIWebBrowserPrint* aWebBrowserPrint,
+                      nsIPrintSettings* aPS)
 {
   NS_ASSERTION(aWebBrowserPrint, "Can't be null");
   NS_ASSERTION(aPS, "Can't be null");
 
   bool isFramesetDocument;
   bool isFramesetFrameSelected;
   bool isIFrameSelected;
   bool isRangeSelection;
@@ -815,29 +874,29 @@ PrepareForPrintDialog(nsIWebBrowserPrint
     } else {
       aPS->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAsIsAndEach);
     }
   } else {
     aPS->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableNone);
   }
 
   // Now determine how to set up the Frame print UI
-  aPS->SetPrintOptions(nsIPrintSettings::kEnableSelectionRB, isRangeSelection || isIFrameSelected);
-
+  aPS->SetPrintOptions(nsIPrintSettings::kEnableSelectionRB,
+                       isRangeSelection || isIFrameSelected);
 }
 
 //----------------------------------------------------------------------------------
 //-- Show Print Dialog
 //----------------------------------------------------------------------------------
-nsresult NativeShowPrintDialog(HWND                aHWnd,
-                               nsIWebBrowserPrint* aWebBrowserPrint,
-                               nsIPrintSettings*   aPrintSettings)
+nsresult
+NativeShowPrintDialog(HWND aHWnd,
+                      nsIWebBrowserPrint* aWebBrowserPrint,
+                      nsIPrintSettings* aPrintSettings)
 {
   PrepareForPrintDialog(aWebBrowserPrint, aPrintSettings);
 
   nsresult rv = ShowNativePrintDialog(aHWnd, aPrintSettings);
   if (aHWnd) {
     ::DestroyWindow(aHWnd);
   }
 
   return rv;
 }
-
--- a/widget/windows/nsPrintDialogUtil.h
+++ b/widget/windows/nsPrintDialogUtil.h
@@ -1,12 +1,13 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef nsFlyOwnDialog_h___
 #define nsFlyOwnDialog_h___
 
-nsresult NativeShowPrintDialog(HWND                aHWnd,
-                               nsIWebBrowserPrint* aWebBrowserPrint,
-                               nsIPrintSettings*   aPrintSettings);
+nsresult
+NativeShowPrintDialog(HWND aHWnd,
+                      nsIWebBrowserPrint* aWebBrowserPrint,
+                      nsIPrintSettings* aPrintSettings);
 
 #endif /* nsFlyOwnDialog_h___ */
--- a/widget/windows/nsPrintDialogWin.cpp
+++ b/widget/windows/nsPrintDialogWin.cpp
@@ -17,106 +17,103 @@
 #include "nsIPrintSettings.h"
 #include "nsIWebBrowserChrome.h"
 #include "nsIWidget.h"
 #include "nsPrintDialogUtil.h"
 #include "nsIPrintSettings.h"
 #include "nsIWebBrowserChrome.h"
 #include "nsQueryObject.h"
 
-static const char *kPageSetupDialogURL = "chrome://global/content/printPageSetup.xul";
+static const char* kPageSetupDialogURL =
+  "chrome://global/content/printPageSetup.xul";
 
 using namespace mozilla;
 using namespace mozilla::widget;
 
 /**
  * ParamBlock
  */
 
-class ParamBlock {
+class ParamBlock
+{
 
 public:
-  ParamBlock()
+  ParamBlock() { mBlock = 0; }
+  ~ParamBlock() { NS_IF_RELEASE(mBlock); }
+  nsresult Init()
   {
-    mBlock = 0;
-  }
-  ~ParamBlock()
-  {
-    NS_IF_RELEASE(mBlock);
-  }
-  nsresult Init() {
     return CallCreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID, &mBlock);
   }
-  nsIDialogParamBlock * operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN { return mBlock; }
-  operator nsIDialogParamBlock * const ()  { return mBlock; }
+  nsIDialogParamBlock* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN
+  {
+    return mBlock;
+  }
+  operator nsIDialogParamBlock* const() { return mBlock; }
 
 private:
-  nsIDialogParamBlock *mBlock;
+  nsIDialogParamBlock* mBlock;
 };
 
 NS_IMPL_ISUPPORTS(nsPrintDialogServiceWin, nsIPrintDialogService)
 
-nsPrintDialogServiceWin::nsPrintDialogServiceWin()
-{
-}
+nsPrintDialogServiceWin::nsPrintDialogServiceWin() {}
 
-nsPrintDialogServiceWin::~nsPrintDialogServiceWin()
-{
-}
+nsPrintDialogServiceWin::~nsPrintDialogServiceWin() {}
 
 NS_IMETHODIMP
 nsPrintDialogServiceWin::Init()
 {
   nsresult rv;
   mWatcher = do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
   return rv;
 }
 
 NS_IMETHODIMP
-nsPrintDialogServiceWin::Show(nsPIDOMWindowOuter *aParent,
-                              nsIPrintSettings *aSettings,
-                              nsIWebBrowserPrint *aWebBrowserPrint)
+nsPrintDialogServiceWin::Show(nsPIDOMWindowOuter* aParent,
+                              nsIPrintSettings* aSettings,
+                              nsIWebBrowserPrint* aWebBrowserPrint)
 {
   NS_ENSURE_ARG(aParent);
   HWND hWnd = GetHWNDForDOMWindow(aParent);
   NS_ASSERTION(hWnd, "Couldn't get native window for PRint Dialog!");
 
   return NativeShowPrintDialog(hWnd, aWebBrowserPrint, aSettings);
 }
 
 NS_IMETHODIMP
-nsPrintDialogServiceWin::ShowPageSetup(nsPIDOMWindowOuter *aParent,
-                                       nsIPrintSettings *aNSSettings)
+nsPrintDialogServiceWin::ShowPageSetup(nsPIDOMWindowOuter* aParent,
+                                       nsIPrintSettings* aNSSettings)
 {
   NS_ENSURE_ARG(aParent);
   NS_ENSURE_ARG(aNSSettings);
 
   ParamBlock block;
   nsresult rv = block.Init();
-  if (NS_FAILED(rv)) return rv;
+  if (NS_FAILED(rv))
+    return rv;
 
   block->SetInt(0, 0);
   rv = DoDialog(aParent, block, aNSSettings, kPageSetupDialogURL);
 
   // if aWebBrowserPrint is not null then we are printing
   // so we want to pass back NS_ERROR_ABORT on cancel
   if (NS_SUCCEEDED(rv)) {
     int32_t status;
     block->GetInt(0, &status);
-    return status == 0?NS_ERROR_ABORT:NS_OK;
+    return status == 0 ? NS_ERROR_ABORT : NS_OK;
   }
 
   return rv;
 }
 
 nsresult
-nsPrintDialogServiceWin::DoDialog(mozIDOMWindowProxy *aParent,
-                                  nsIDialogParamBlock *aParamBlock,
+nsPrintDialogServiceWin::DoDialog(mozIDOMWindowProxy* aParent,
+                                  nsIDialogParamBlock* aParamBlock,
                                   nsIPrintSettings* aPS,
-                                  const char *aChromeURL)
+                                  const char* aChromeURL)
 {
   NS_ENSURE_ARG(aParamBlock);
   NS_ENSURE_ARG(aPS);
   NS_ENSURE_ARG(aChromeURL);
 
   if (!mWatcher)
     return NS_ERROR_FAILURE;
 
@@ -131,73 +128,78 @@ nsPrintDialogServiceWin::DoDialog(mozIDO
   }
 
   // create a nsIMutableArray of the parameters
   // being passed to the window
   nsCOMPtr<nsIMutableArray> array = nsArray::Create();
 
   nsCOMPtr<nsISupports> psSupports(do_QueryInterface(aPS));
   NS_ASSERTION(psSupports, "PrintSettings must be a supports");
-  array->AppendElement(psSupports, /*weak =*/ false);
+  array->AppendElement(psSupports, /*weak =*/false);
 
   nsCOMPtr<nsISupports> blkSupps(do_QueryInterface(aParamBlock));
   NS_ASSERTION(blkSupps, "IOBlk must be a supports");
-  array->AppendElement(blkSupps, /*weak =*/ false);
+  array->AppendElement(blkSupps, /*weak =*/false);
 
   nsCOMPtr<mozIDOMWindowProxy> dialog;
   nsresult rv = mWatcher->OpenWindow(aParent,
                                      aChromeURL,
                                      "_blank",
                                      "centerscreen,chrome,modal,titlebar",
                                      array,
                                      getter_AddRefs(dialog));
 
-    return rv;
+  return rv;
 }
 
 HWND
-nsPrintDialogServiceWin::GetHWNDForDOMWindow(mozIDOMWindowProxy *aWindow)
+nsPrintDialogServiceWin::GetHWNDForDOMWindow(mozIDOMWindowProxy* aWindow)
 {
   nsCOMPtr<nsIWebBrowserChrome> chrome;
 
   // We might be embedded so check this path first
   if (mWatcher) {
     nsCOMPtr<mozIDOMWindowProxy> fosterParent;
     // it will be a dependent window. try to find a foster parent.
     if (!aWindow) {
-        mWatcher->GetActiveWindow(getter_AddRefs(fosterParent));
-        aWindow = fosterParent;
+      mWatcher->GetActiveWindow(getter_AddRefs(fosterParent));
+      aWindow = fosterParent;
     }
     mWatcher->GetChromeForWindow(aWindow, getter_AddRefs(chrome));
   }
 
   if (chrome) {
     nsCOMPtr<nsIEmbeddingSiteWindow> site(do_QueryInterface(chrome));
     if (site) {
       HWND w;
-      site->GetSiteWindow(reinterpret_cast<void **>(&w));
+      site->GetSiteWindow(reinterpret_cast<void**>(&w));
       return w;
     }
   }
 
   // Now we might be the Browser so check this path
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
 
   nsCOMPtr<nsIDocShellTreeItem> treeItem =
     do_QueryInterface(window->GetDocShell());
-  if (!treeItem) return nullptr;
+  if (!treeItem)
+    return nullptr;
 
   nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
   treeItem->GetTreeOwner(getter_AddRefs(treeOwner));
-  if (!treeOwner) return nullptr;
+  if (!treeOwner)
+    return nullptr;
 
   nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome(do_GetInterface(treeOwner));
-  if (!webBrowserChrome) return nullptr;
+  if (!webBrowserChrome)
+    return nullptr;
 
   nsCOMPtr<nsIBaseWindow> baseWin(do_QueryInterface(webBrowserChrome));
-  if (!baseWin) return nullptr;
+  if (!baseWin)
+    return nullptr;
 
   nsCOMPtr<nsIWidget> widget;
   baseWin->GetMainWidget(getter_AddRefs(widget));
-  if (!widget) return nullptr;
+  if (!widget)
+    return nullptr;
 
   return (HWND)widget->GetNativeData(NS_NATIVE_TMP_WINDOW);
 }
--- a/widget/windows/nsPrintDialogWin.h
+++ b/widget/windows/nsPrintDialogWin.h
@@ -19,25 +19,26 @@ class nsPrintDialogServiceWin : public n
   virtual ~nsPrintDialogServiceWin();
 
 public:
   nsPrintDialogServiceWin();
 
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD Init() override;
-  NS_IMETHOD Show(nsPIDOMWindowOuter *aParent, nsIPrintSettings *aSettings,
-                  nsIWebBrowserPrint *aWebBrowserPrint) override;
-  NS_IMETHOD ShowPageSetup(nsPIDOMWindowOuter *aParent,
-                           nsIPrintSettings *aSettings) override;
+  NS_IMETHOD Show(nsPIDOMWindowOuter* aParent,
+                  nsIPrintSettings* aSettings,
+                  nsIWebBrowserPrint* aWebBrowserPrint) override;
+  NS_IMETHOD ShowPageSetup(nsPIDOMWindowOuter* aParent,
+                           nsIPrintSettings* aSettings) override;
 
 private:
-  nsresult DoDialog(mozIDOMWindowProxy *aParent,
-                    nsIDialogParamBlock *aParamBlock,
+  nsresult DoDialog(mozIDOMWindowProxy* aParent,
+                    nsIDialogParamBlock* aParamBlock,
                     nsIPrintSettings* aPS,
-                    const char *aChromeURL);
+                    const char* aChromeURL);
 
-  HWND GetHWNDForDOMWindow(mozIDOMWindowProxy *aWindow);
+  HWND GetHWNDForDOMWindow(mozIDOMWindowProxy* aWindow);
 
   nsCOMPtr<nsIWindowWatcher> mWatcher;
 };
 
 #endif