Add m-esr52 at 52.6.0

1 files changed, 1383 insertions, 0 deletions

diff --git a/widget/windows/nsFilePicker.cpp b/widget/windows/nsFilePicker.cpp
new file mode 100644
index 000000000..53857cf5e
--- /dev/null
+++ b/widget/windows/nsFilePicker.cpp
@@ -0,0 +1,1383 @@
+/* -*- 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/. */
+
+#include "nsFilePicker.h"
+
+#include <shlobj.h>
+#include <shlwapi.h>
+#include <cderr.h>
+
+#include "mozilla/mscom/EnsureMTA.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/WindowsVersion.h"
+#include "nsReadableUtils.h"
+#include "nsNetUtil.h"
+#include "nsWindow.h"
+#include "nsILoadContext.h"
+#include "nsIServiceManager.h"
+#include "nsIURL.h"
+#include "nsIStringBundle.h"
+#include "nsEnumeratorUtils.h"
+#include "nsCRT.h"
+#include "nsString.h"
+#include "nsToolkit.h"
+#include "WinUtils.h"
+#include "nsPIDOMWindow.h"
+#include "GeckoProfiler.h"
+
+using mozilla::IsVistaOrLater;
+using mozilla::IsWin8OrLater;
+using mozilla::MakeUnique;
+using mozilla::mscom::EnsureMTA;
+using mozilla::UniquePtr;
+using namespace mozilla::widget;
+
+char16_t *nsFilePicker::mLastUsedUnicodeDirectory;
+char nsFilePicker::mLastUsedDirectory[MAX_PATH+1] = { 0 };
+
+static const wchar_t kDialogPtrProp[] = L"DialogPtrProperty";
+static const DWORD kDialogTimerID = 9999;
+static const unsigned long kDialogTimerTimeout = 300;
+
+#define MAX_EXTENSION_LENGTH 10
+#define FILE_BUFFER_SIZE     4096 
+
+typedef DWORD FILEOPENDIALOGOPTIONS;
+
+///////////////////////////////////////////////////////////////////////////////
+// Helper classes
+
+// Manages matching SuppressBlurEvents calls on the parent widget.
+class AutoSuppressEvents
+{
+public:
+  explicit AutoSuppressEvents(nsIWidget* aWidget) :
+    mWindow(static_cast<nsWindow *>(aWidget)) {
+    SuppressWidgetEvents(true);
+  }
+
+  ~AutoSuppressEvents() {
+    SuppressWidgetEvents(false);
+  }
+private:
+  void SuppressWidgetEvents(bool aFlag) {
+    if (mWindow) {
+      mWindow->SuppressBlurEvents(aFlag);
+    }
+  }
+  RefPtr<nsWindow> mWindow;
+};
+
+// Manages the current working path.
+class AutoRestoreWorkingPath
+{
+public:
+  AutoRestoreWorkingPath() {
+    DWORD bufferLength = GetCurrentDirectoryW(0, nullptr);
+    mWorkingPath = MakeUnique<wchar_t[]>(bufferLength);
+    if (GetCurrentDirectoryW(bufferLength, mWorkingPath.get()) == 0) {
+      mWorkingPath = nullptr;
+    }
+  }
+
+  ~AutoRestoreWorkingPath() {
+    if (HasWorkingPath()) {
+      ::SetCurrentDirectoryW(mWorkingPath.get());
+    }
+  }
+
+  inline bool HasWorkingPath() const {
+    return mWorkingPath != nullptr;
+  }
+private:
+  UniquePtr<wchar_t[]> mWorkingPath;
+};
+
+// Manages NS_NATIVE_TMP_WINDOW child windows. NS_NATIVE_TMP_WINDOWs are
+// temporary child windows of mParentWidget created to address RTL issues
+// in picker dialogs. We are responsible for destroying these.
+class AutoDestroyTmpWindow
+{
+public:
+  explicit AutoDestroyTmpWindow(HWND aTmpWnd) :
+    mWnd(aTmpWnd) {
+  }
+
+  ~AutoDestroyTmpWindow() {
+    if (mWnd)
+      DestroyWindow(mWnd);
+  }
+  
+  inline HWND get() const { return mWnd; }
+private:
+  HWND mWnd;
+};
+
+// Manages matching PickerOpen/PickerClosed calls on the parent widget.
+class AutoWidgetPickerState
+{
+public:
+  explicit AutoWidgetPickerState(nsIWidget* aWidget) :
+    mWindow(static_cast<nsWindow *>(aWidget)) {
+    PickerState(true);
+  }
+
+  ~AutoWidgetPickerState() {
+    PickerState(false);
+  }
+private:
+  void PickerState(bool aFlag) {
+    if (mWindow) {
+      if (aFlag)
+        mWindow->PickerOpen();
+      else
+        mWindow->PickerClosed();
+    }
+  }
+  RefPtr<nsWindow> mWindow;
+};
+
+// Manages a simple callback timer
+class AutoTimerCallbackCancel
+{
+public:
+  AutoTimerCallbackCancel(nsFilePicker* aTarget,
+                          nsTimerCallbackFunc aCallbackFunc) {
+    Init(aTarget, aCallbackFunc);
+  }
+
+  ~AutoTimerCallbackCancel() {
+    if (mPickerCallbackTimer) {
+      mPickerCallbackTimer->Cancel();
+    }
+  }
+
+private:
+  void Init(nsFilePicker* aTarget,
+            nsTimerCallbackFunc aCallbackFunc) {
+    mPickerCallbackTimer = do_CreateInstance("@mozilla.org/timer;1");
+    if (!mPickerCallbackTimer) {
+      NS_WARNING("do_CreateInstance for timer failed??");
+      return;
+    }
+    mPickerCallbackTimer->InitWithFuncCallback(aCallbackFunc,
+                                               aTarget,
+                                               kDialogTimerTimeout,
+                                               nsITimer::TYPE_REPEATING_SLACK);
+  }
+  nsCOMPtr<nsITimer> mPickerCallbackTimer;
+    
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// nsIFilePicker
+
+nsFilePicker::nsFilePicker() :
+  mSelectedType(1)
+  , mDlgWnd(nullptr)
+  , mFDECookie(0)
+{
+   CoInitialize(nullptr);
+}
+
+nsFilePicker::~nsFilePicker()
+{
+  if (mLastUsedUnicodeDirectory) {
+    free(mLastUsedUnicodeDirectory);
+    mLastUsedUnicodeDirectory = nullptr;
+  }
+  CoUninitialize();
+}
+
+NS_IMPL_ISUPPORTS(nsFilePicker, nsIFilePicker)
+
+NS_IMETHODIMP nsFilePicker::Init(mozIDOMWindowProxy *aParent, const nsAString& aTitle, int16_t aMode)
+{
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aParent);
+  nsIDocShell* docShell = window ? window->GetDocShell() : nullptr;  
+  mLoadContext = do_QueryInterface(docShell);
+  
+  return nsBaseFilePicker::Init(aParent, aTitle, aMode);
+}
+
+STDMETHODIMP nsFilePicker::QueryInterface(REFIID refiid, void** ppvResult)
+{
+  *ppvResult = nullptr;
+  if (IID_IUnknown == refiid ||
+      refiid == IID_IFileDialogEvents) {
+    *ppvResult = this;
+  }
+
+  if (nullptr != *ppvResult) {
+    ((LPUNKNOWN)*ppvResult)->AddRef();
+    return S_OK;
+  }
+
+  return E_NOINTERFACE;
+}
+
+/*
+ * XP picker callbacks
+ */
+
+// Show - Display the file dialog
+int CALLBACK
+BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
+{
+  if (uMsg == BFFM_INITIALIZED)
+  {
+    char16_t * filePath = (char16_t *) lpData;
+    if (filePath)
+      ::SendMessageW(hwnd, BFFM_SETSELECTIONW,
+                     TRUE /* true because lpData is a path string */,
+                     lpData);
+  }
+  return 0;
+}
+
+static void
+EnsureWindowVisible(HWND hwnd) 
+{
+  // Obtain the monitor which has the largest area of intersection 
+  // with the window, or nullptr if there is no intersection.
+  HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONULL);
+  if (!monitor) {
+    // The window is not visible, we should reposition it to the same place as its parent
+    HWND parentHwnd = GetParent(hwnd);
+    RECT parentRect;
+    GetWindowRect(parentHwnd, &parentRect);
+    SetWindowPos(hwnd, nullptr, parentRect.left, parentRect.top, 0, 0,
+                 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
+  }
+}
+
+// Callback hook which will ensure that the window is visible. Currently
+// only in use on os <= XP.
+UINT_PTR CALLBACK
+nsFilePicker::FilePickerHook(HWND hwnd,
+                             UINT msg,
+                             WPARAM wParam,
+                             LPARAM lParam) 
+{
+  switch(msg) {
+    case WM_NOTIFY:
+      {
+        LPOFNOTIFYW lpofn = (LPOFNOTIFYW) lParam;
+        if (!lpofn || !lpofn->lpOFN) {
+          return 0;
+        }
+        
+        if (CDN_INITDONE == lpofn->hdr.code) {
+          // The Window will be automatically moved to the last position after
+          // CDN_INITDONE.  We post a message to ensure the window will be visible
+          // so it will be done after the automatic last position window move.
+          PostMessage(hwnd, MOZ_WM_ENSUREVISIBLE, 0, 0);
+        }
+      }
+      break;
+    case MOZ_WM_ENSUREVISIBLE:
+      EnsureWindowVisible(GetParent(hwnd));
+      break;
+    case WM_INITDIALOG:
+      {
+        OPENFILENAMEW* pofn = reinterpret_cast<OPENFILENAMEW*>(lParam);
+        SetProp(hwnd, kDialogPtrProp, (HANDLE)pofn->lCustData);
+        nsFilePicker* picker = reinterpret_cast<nsFilePicker*>(pofn->lCustData);
+        if (picker) {
+          picker->SetDialogHandle(hwnd);
+          SetTimer(hwnd, kDialogTimerID, kDialogTimerTimeout, nullptr);
+        }
+      }
+      break;
+    case WM_TIMER:
+      {
+        // Check to see if our parent has been torn down, if so, we close too.
+        if (wParam == kDialogTimerID) {
+          nsFilePicker* picker = 
+            reinterpret_cast<nsFilePicker*>(GetProp(hwnd, kDialogPtrProp));
+          if (picker && picker->ClosePickerIfNeeded(true)) {
+            KillTimer(hwnd, kDialogTimerID);
+          }
+        }
+      }
+      break;
+  }
+  return 0;
+}
+
+
+// Callback hook which will dynamically allocate a buffer large enough
+// for the file picker dialog.  Currently only in use on  os <= XP.
+UINT_PTR CALLBACK
+nsFilePicker::MultiFilePickerHook(HWND hwnd,
+                                  UINT msg,
+                                  WPARAM wParam,
+                                  LPARAM lParam)
+{
+  switch (msg) {
+    case WM_INITDIALOG:
+      {
+        // Finds the child drop down of a File Picker dialog and sets the 
+        // maximum amount of text it can hold when typed in manually.
+        // A wParam of 0 mean 0x7FFFFFFE characters.
+        HWND comboBox = FindWindowEx(GetParent(hwnd), nullptr, 
+                                     L"ComboBoxEx32", nullptr );
+        if(comboBox)
+          SendMessage(comboBox, CB_LIMITTEXT, 0, 0);
+        // Store our nsFilePicker ptr for future use
+        OPENFILENAMEW* pofn = reinterpret_cast<OPENFILENAMEW*>(lParam);
+        SetProp(hwnd, kDialogPtrProp, (HANDLE)pofn->lCustData);
+        nsFilePicker* picker =
+          reinterpret_cast<nsFilePicker*>(pofn->lCustData);
+        if (picker) {
+          picker->SetDialogHandle(hwnd);
+          SetTimer(hwnd, kDialogTimerID, kDialogTimerTimeout, nullptr);
+        }
+      }
+      break;
+    case WM_NOTIFY:
+      {
+        LPOFNOTIFYW lpofn = (LPOFNOTIFYW) lParam;
+        if (!lpofn || !lpofn->lpOFN) {
+          return 0;
+        }
+        // CDN_SELCHANGE is sent when the selection in the list box of the file
+        // selection dialog changes
+        if (lpofn->hdr.code == CDN_SELCHANGE) {
+          HWND parentHWND = GetParent(hwnd);
+
+          // Get the required size for the selected files buffer
+          UINT newBufLength = 0; 
+          int requiredBufLength = CommDlg_OpenSave_GetSpecW(parentHWND, 
+                                                            nullptr, 0);
+          if(requiredBufLength >= 0)
+            newBufLength += requiredBufLength;
+          else
+            newBufLength += MAX_PATH;
+
+          // If the user selects multiple files, the buffer contains the 
+          // current directory followed by the file names of the selected 
+          // files. So make room for the directory path.  If the user
+          // selects a single file, it is no harm to add extra space.
+          requiredBufLength = CommDlg_OpenSave_GetFolderPathW(parentHWND, 
+                                                              nullptr, 0);
+          if(requiredBufLength >= 0)
+            newBufLength += requiredBufLength;
+          else
+            newBufLength += MAX_PATH;
+
+          // Check if lpstrFile and nMaxFile are large enough
+          if (newBufLength > lpofn->lpOFN->nMaxFile) {
+            if (lpofn->lpOFN->lpstrFile)
+              delete[] lpofn->lpOFN->lpstrFile;
+
+            // We allocate FILE_BUFFER_SIZE more bytes than is needed so that
+            // if the user selects a file and holds down shift and down to 
+            // select  additional items, we will not continuously reallocate
+            newBufLength += FILE_BUFFER_SIZE;
+
+            wchar_t* filesBuffer = new wchar_t[newBufLength];
+            ZeroMemory(filesBuffer, newBufLength * sizeof(wchar_t));
+
+            lpofn->lpOFN->lpstrFile = filesBuffer;
+            lpofn->lpOFN->nMaxFile  = newBufLength;
+          }
+        }
+      }
+      break;
+    case WM_TIMER:
+      {
+        // Check to see if our parent has been torn down, if so, we close too.
+        if (wParam == kDialogTimerID) {
+          nsFilePicker* picker =
+            reinterpret_cast<nsFilePicker*>(GetProp(hwnd, kDialogPtrProp));
+          if (picker && picker->ClosePickerIfNeeded(true)) {
+            KillTimer(hwnd, kDialogTimerID);
+          }
+        }
+      }
+      break;
+  }
+
+  return FilePickerHook(hwnd, msg, wParam, lParam);
+}
+
+/*
+ * Vista+ callbacks
+ */
+
+HRESULT
+nsFilePicker::OnFileOk(IFileDialog *pfd)
+{
+  return S_OK;
+}
+
+HRESULT
+nsFilePicker::OnFolderChanging(IFileDialog *pfd,
+                               IShellItem *psiFolder)
+{
+  return S_OK;
+}
+
+HRESULT
+nsFilePicker::OnFolderChange(IFileDialog *pfd)
+{
+  return S_OK;
+}
+
+HRESULT
+nsFilePicker::OnSelectionChange(IFileDialog *pfd)
+{
+  return S_OK;
+}
+
+HRESULT
+nsFilePicker::OnShareViolation(IFileDialog *pfd,
+                               IShellItem *psi,
+                               FDE_SHAREVIOLATION_RESPONSE *pResponse)
+{
+  return S_OK;
+}
+
+HRESULT
+nsFilePicker::OnTypeChange(IFileDialog *pfd)
+{
+  // Failures here result in errors due to security concerns.
+  RefPtr<IOleWindow> win;
+  pfd->QueryInterface(IID_IOleWindow, getter_AddRefs(win));
+  if (!win) {
+    NS_ERROR("Could not retrieve the IOleWindow interface for IFileDialog.");
+    return S_OK;
+  }
+  HWND hwnd = nullptr;
+  win->GetWindow(&hwnd);
+  if (!hwnd) {
+    NS_ERROR("Could not retrieve the HWND for IFileDialog.");
+    return S_OK;
+  }
+  
+  SetDialogHandle(hwnd);
+  return S_OK;
+}
+
+HRESULT
+nsFilePicker::OnOverwrite(IFileDialog *pfd,
+                          IShellItem *psi,
+                          FDE_OVERWRITE_RESPONSE *pResponse)
+{
+  return S_OK;
+}
+
+/*
+ * Close on parent close logic
+ */
+
+bool
+nsFilePicker::ClosePickerIfNeeded(bool aIsXPDialog)
+{
+  if (!mParentWidget || !mDlgWnd)
+    return false;
+
+  nsWindow *win = static_cast<nsWindow *>(mParentWidget.get());
+  // Note, the xp callbacks hand us an inner window, so we have to step up
+  // one to get the actual dialog.
+  HWND dlgWnd;
+  if (aIsXPDialog)
+    dlgWnd = GetParent(mDlgWnd);
+  else
+    dlgWnd = mDlgWnd;
+  if (IsWindow(dlgWnd) && IsWindowVisible(dlgWnd) && win->DestroyCalled()) {
+    wchar_t className[64];
+    // Make sure we have the right window
+    if (GetClassNameW(dlgWnd, className, mozilla::ArrayLength(className)) &&
+        !wcscmp(className, L"#32770") &&
+        DestroyWindow(dlgWnd)) {
+      mDlgWnd = nullptr;
+      return true;
+    }
+  }
+  return false;
+}
+
+void
+nsFilePicker::PickerCallbackTimerFunc(nsITimer *aTimer, void *aCtx)
+{
+  nsFilePicker* picker = (nsFilePicker*)aCtx;
+  if (picker->ClosePickerIfNeeded(false)) {
+    aTimer->Cancel();
+  }
+}
+
+void
+nsFilePicker::SetDialogHandle(HWND aWnd)
+{
+  if (!aWnd || mDlgWnd)
+    return;
+  mDlgWnd = aWnd;
+}
+
+/*
+ * Folder picker invocation
+ */
+
+// Open the older XP style folder picker dialog. We end up in this call
+// on XP systems or when platform is built without the longhorn SDK.
+bool
+nsFilePicker::ShowXPFolderPicker(const nsString& aInitialDir)
+{
+  bool result = false;
+
+  auto dirBuffer = MakeUnique<wchar_t[]>(FILE_BUFFER_SIZE);
+  wcsncpy(dirBuffer.get(), aInitialDir.get(), FILE_BUFFER_SIZE);
+  dirBuffer[FILE_BUFFER_SIZE-1] = '\0';
+
+  AutoDestroyTmpWindow adtw((HWND)(mParentWidget.get() ?
+    mParentWidget->GetNativeData(NS_NATIVE_TMP_WINDOW) : nullptr));
+
+  BROWSEINFOW browserInfo = {0};
+  browserInfo.pidlRoot       = nullptr;
+  browserInfo.pszDisplayName = dirBuffer.get();
+  browserInfo.lpszTitle      = mTitle.get();
+  browserInfo.ulFlags        = BIF_USENEWUI | BIF_RETURNONLYFSDIRS;
+  browserInfo.hwndOwner      = adtw.get(); 
+  browserInfo.iImage         = 0;
+  browserInfo.lParam         = reinterpret_cast<LPARAM>(this);
+
+  if (!aInitialDir.IsEmpty()) {
+    // the dialog is modal so that |initialDir.get()| will be valid in 
+    // BrowserCallbackProc. Thus, we don't need to clone it.
+    browserInfo.lParam = (LPARAM) aInitialDir.get();
+    browserInfo.lpfn   = &BrowseCallbackProc;
+  } else {
+    browserInfo.lParam = 0;
+    browserInfo.lpfn   = nullptr;
+  }
+
+  LPITEMIDLIST list = ::SHBrowseForFolderW(&browserInfo);
+  if (list) {
+    result = ::SHGetPathFromIDListW(list, dirBuffer.get());
+    if (result)
+      mUnicodeFile.Assign(static_cast<const wchar_t*>(dirBuffer.get()));
+    // free PIDL
+    CoTaskMemFree(list);
+  }
+
+  return result;
+}
+
+/*
+ * Show a folder picker post Windows XP
+ * 
+ * @param aInitialDir   The initial directory, the last used directory will be
+ *                      used if left blank.
+ * @param aWasInitError Out parameter will hold true if there was an error
+ *                      before the folder picker is shown.
+ * @return true if a file was selected successfully.
+*/
+bool
+nsFilePicker::ShowFolderPicker(const nsString& aInitialDir, bool &aWasInitError)
+{
+  if (!IsWin8OrLater()) {
+    // Some Windows 7 users are experiencing a race condition when some dlls
+    // that are loaded by the file picker cause a crash while attempting to shut
+    // down the COM multithreaded apartment. By instantiating EnsureMTA, we hold
+    // an additional reference to the MTA that should prevent this race, since
+    // the MTA will remain alive until shutdown.
+    EnsureMTA ensureMTA;
+  }
+
+  RefPtr<IFileOpenDialog> dialog;
+  if (FAILED(CoCreateInstance(CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC,
+                              IID_IFileOpenDialog,
+                              getter_AddRefs(dialog)))) {
+    aWasInitError = true;
+    return false;
+  }
+  aWasInitError = false;
+
+  // hook up event callbacks
+  dialog->Advise(this, &mFDECookie);
+
+  // options
+  FILEOPENDIALOGOPTIONS fos = FOS_PICKFOLDERS;
+  dialog->SetOptions(fos);
+ 
+  // initial strings
+  dialog->SetTitle(mTitle.get());
+
+  if (!mOkButtonLabel.IsEmpty()) {
+    dialog->SetOkButtonLabel(mOkButtonLabel.get());
+  }
+
+  if (!aInitialDir.IsEmpty()) {
+    RefPtr<IShellItem> folder;
+    if (SUCCEEDED(
+          WinUtils::SHCreateItemFromParsingName(aInitialDir.get(), nullptr,
+                                                IID_IShellItem,
+                                                getter_AddRefs(folder)))) {
+      dialog->SetFolder(folder);
+    }
+  }
+
+  AutoDestroyTmpWindow adtw((HWND)(mParentWidget.get() ?
+    mParentWidget->GetNativeData(NS_NATIVE_TMP_WINDOW) : nullptr));
+ 
+  // display
+  RefPtr<IShellItem> item;
+  if (FAILED(dialog->Show(adtw.get())) ||
+      FAILED(dialog->GetResult(getter_AddRefs(item))) ||
+      !item) {
+    dialog->Unadvise(mFDECookie);
+    return false;
+  }
+  dialog->Unadvise(mFDECookie);
+
+  // results
+
+  // If the user chose a Win7 Library, resolve to the library's
+  // default save folder.
+  RefPtr<IShellItem> folderPath;
+  RefPtr<IShellLibrary> shellLib;
+  CoCreateInstance(CLSID_ShellLibrary, nullptr, CLSCTX_INPROC,
+                   IID_IShellLibrary, getter_AddRefs(shellLib));
+  if (shellLib &&
+      SUCCEEDED(shellLib->LoadLibraryFromItem(item, STGM_READ)) &&
+      SUCCEEDED(shellLib->GetDefaultSaveFolder(DSFT_DETECT, IID_IShellItem,
+                                               getter_AddRefs(folderPath)))) {
+    item.swap(folderPath);
+  }
+
+  // get the folder's file system path
+  return WinUtils::GetShellItemPath(item, mUnicodeFile);
+}
+
+/*
+ * File open and save picker invocation
+ */
+
+/* static */ bool
+nsFilePicker::GetFileNameWrapper(OPENFILENAMEW* ofn, PickerType aType)
+{
+  MOZ_SEH_TRY {
+    if (aType == PICKER_TYPE_OPEN)
+      return ::GetOpenFileNameW(ofn);
+    else if (aType == PICKER_TYPE_SAVE)
+      return ::GetSaveFileNameW(ofn);
+  } MOZ_SEH_EXCEPT(true) {
+    NS_ERROR("nsFilePicker GetFileName win32 call generated an exception! This is bad!");
+  }
+  return false;
+}
+
+bool
+nsFilePicker::FilePickerWrapper(OPENFILENAMEW* ofn, PickerType aType)
+{
+  if (!ofn)
+    return false;
+  AutoWidgetPickerState awps(mParentWidget);
+  return GetFileNameWrapper(ofn, aType);
+}
+
+bool
+nsFilePicker::ShowXPFilePicker(const nsString& aInitialDir)
+{
+  OPENFILENAMEW ofn = {0};
+  ofn.lStructSize = sizeof(ofn);
+  nsString filterBuffer = mFilterList;
+                                
+  auto fileBuffer = MakeUnique<wchar_t[]>(FILE_BUFFER_SIZE);
+  wcsncpy(fileBuffer.get(),  mDefaultFilePath.get(), FILE_BUFFER_SIZE);
+  fileBuffer[FILE_BUFFER_SIZE-1] = '\0'; // null terminate in case copy truncated
+
+  if (!aInitialDir.IsEmpty()) {
+    ofn.lpstrInitialDir = aInitialDir.get();
+  }
+
+  AutoDestroyTmpWindow adtw((HWND) (mParentWidget.get() ?
+    mParentWidget->GetNativeData(NS_NATIVE_TMP_WINDOW) : nullptr));
+
+  ofn.lpstrTitle   = (LPCWSTR)mTitle.get();
+  ofn.lpstrFilter  = (LPCWSTR)filterBuffer.get();
+  ofn.nFilterIndex = mSelectedType;
+  ofn.lpstrFile    = fileBuffer.get();
+  ofn.nMaxFile     = FILE_BUFFER_SIZE;
+  ofn.hwndOwner    = adtw.get();
+  ofn.lCustData    = reinterpret_cast<LPARAM>(this);
+  ofn.Flags = OFN_SHAREAWARE | OFN_LONGNAMES | OFN_OVERWRITEPROMPT |
+              OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_ENABLESIZING | 
+              OFN_EXPLORER;
+
+  // Windows Vista and up won't allow you to use the new looking dialogs with
+  // a hook procedure.  The hook procedure fixes a problem on XP dialogs for
+  // file picker visibility.  Vista and up automatically ensures the file 
+  // picker is always visible.
+  if (!IsVistaOrLater()) {
+    ofn.lpfnHook = FilePickerHook;
+    ofn.Flags |= OFN_ENABLEHOOK;
+  }
+
+  // Handle add to recent docs settings
+  if (IsPrivacyModeEnabled() || !mAddToRecentDocs) {
+    ofn.Flags |= OFN_DONTADDTORECENT;
+  }
+
+  NS_NAMED_LITERAL_STRING(htmExt, "html");
+
+  if (!mDefaultExtension.IsEmpty()) {
+    ofn.lpstrDefExt = mDefaultExtension.get();
+  } else if (IsDefaultPathHtml()) {
+    // Get file extension from suggested filename to detect if we are
+    // saving an html file.
+    // This is supposed to append ".htm" if user doesn't supply an
+    // extension but the behavior is sort of weird:
+    // - Often appends ".html" even if you have an extension
+    // - It obeys your extension if you put quotes around name
+    ofn.lpstrDefExt = htmExt.get();
+  }
+
+  // When possible, instead of using OFN_NOCHANGEDIR to ensure the current
+  // working directory will not change from this call, we will retrieve the
+  // current working directory before the call and restore it after the 
+  // call.  This flag causes problems on Windows XP for paths that are
+  // selected like  C:test.txt where the user is currently at C:\somepath
+  // In which case expected result should be C:\somepath\test.txt
+  AutoRestoreWorkingPath restoreWorkingPath;
+  // If we can't get the current working directory, the best case is to
+  // use the OFN_NOCHANGEDIR flag
+  if (!restoreWorkingPath.HasWorkingPath()) {
+    ofn.Flags |= OFN_NOCHANGEDIR;
+  }
+
+  bool result = false;
+
+  switch(mMode) {
+    case modeOpen:
+      // FILE MUST EXIST!
+      ofn.Flags |= OFN_FILEMUSTEXIST;
+      result = FilePickerWrapper(&ofn, PICKER_TYPE_OPEN);
+      break;
+
+    case modeOpenMultiple:
+      ofn.Flags |= OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT;
+
+      // The hook set here ensures that the buffer returned will always be
+      // large enough to hold all selected files.  The hook may modify the
+      // value of ofn.lpstrFile and deallocate the old buffer that it pointed
+      // to (fileBuffer). The hook assumes that the passed in value is heap 
+      // allocated and that the returned value should be freed by the caller.
+      // If the hook changes the buffer, it will deallocate the old buffer.
+      // This fix would be nice to have in Vista and up, but it would force
+      // the file picker to use the old style dialogs because hooks are not
+      // allowed in the new file picker UI.  We need to eventually move to
+      // the new Common File Dialogs for Vista and up.
+      if (!IsVistaOrLater()) {
+        ofn.lpfnHook = MultiFilePickerHook;
+        fileBuffer.release();
+        result = FilePickerWrapper(&ofn, PICKER_TYPE_OPEN);
+        fileBuffer.reset(ofn.lpstrFile);
+      } else {
+        result = FilePickerWrapper(&ofn, PICKER_TYPE_OPEN);
+      }
+      break;
+
+    case modeSave:
+      {
+        ofn.Flags |= OFN_NOREADONLYRETURN;
+
+        // Don't follow shortcuts when saving a shortcut, this can be used
+        // to trick users (bug 271732)
+        if (IsDefaultPathLink())
+          ofn.Flags |= OFN_NODEREFERENCELINKS;
+
+        result = FilePickerWrapper(&ofn, PICKER_TYPE_SAVE);
+        if (!result) {
+          // Error, find out what kind.
+          if (GetLastError() == ERROR_INVALID_PARAMETER ||
+              CommDlgExtendedError() == FNERR_INVALIDFILENAME) {
+            // Probably the default file name is too long or contains illegal
+            // characters. Try again, without a starting file name.
+            ofn.lpstrFile[0] = L'\0';
+            result = FilePickerWrapper(&ofn, PICKER_TYPE_SAVE);
+          }
+        }
+      }
+      break;
+
+    default:
+      NS_NOTREACHED("unsupported file picker mode");
+      return false;
+  }
+
+  if (!result)
+    return false;
+
+  // Remember what filter type the user selected
+  mSelectedType = (int16_t)ofn.nFilterIndex;
+
+  // Single file selection, we're done
+  if (mMode != modeOpenMultiple) {
+    GetQualifiedPath(fileBuffer.get(), mUnicodeFile);
+    return true;
+  }
+
+  // Set user-selected location of file or directory.  From msdn's "Open and
+  // Save As Dialog Boxes" section:
+  // If you specify OFN_EXPLORER, the directory and file name strings are '\0'
+  // separated, with an extra '\0' character after the last file name. This
+  // format enables the Explorer-style dialog boxes to return long file names
+  // that include spaces. 
+  wchar_t *current = fileBuffer.get();
+  
+  nsAutoString dirName(current);
+  // Sometimes dirName contains a trailing slash and sometimes it doesn't:
+  if (current[dirName.Length() - 1] != '\\')
+    dirName.Append((char16_t)'\\');
+  
+  while (current && *current && *(current + wcslen(current) + 1)) {
+    current = current + wcslen(current) + 1;
+    
+    nsCOMPtr<nsIFile> file = do_CreateInstance("@mozilla.org/file/local;1");
+    NS_ENSURE_TRUE(file, false);
+
+    // Only prepend the directory if the path specified is a relative path
+    nsAutoString path;
+    if (PathIsRelativeW(current)) {
+      path = dirName + nsDependentString(current);
+    } else {
+      path = current;
+    }
+
+    nsAutoString canonicalizedPath;
+    GetQualifiedPath(path.get(), canonicalizedPath);
+    if (NS_FAILED(file->InitWithPath(canonicalizedPath)) ||
+        !mFiles.AppendObject(file))
+      return false;
+  }
+  
+  // Handle the case where the user selected just one file. From msdn: If you
+  // specify OFN_ALLOWMULTISELECT and the user selects only one file the
+  // lpstrFile string does not have a separator between the path and file name.
+  if (current && *current && (current == fileBuffer.get())) {
+    nsCOMPtr<nsIFile> file = do_CreateInstance("@mozilla.org/file/local;1");
+    NS_ENSURE_TRUE(file, false);
+    
+    nsAutoString canonicalizedPath;
+    GetQualifiedPath(current, canonicalizedPath);
+    if (NS_FAILED(file->InitWithPath(canonicalizedPath)) ||
+        !mFiles.AppendObject(file))
+      return false;
+  }
+
+  return true;
+}
+
+/*
+ * Show a file picker post Windows XP
+ * 
+ * @param aInitialDir   The initial directory, the last used directory will be
+ *                      used if left blank.
+ * @param aWasInitError Out parameter will hold true if there was an error
+ *                      before the file picker is shown.
+ * @return true if a file was selected successfully.
+*/
+bool
+nsFilePicker::ShowFilePicker(const nsString& aInitialDir, bool &aWasInitError)
+{
+  PROFILER_LABEL_FUNC(js::ProfileEntry::Category::OTHER);
+
+  if (!IsWin8OrLater()) {
+    // Some Windows 7 users are experiencing a race condition when some dlls
+    // that are loaded by the file picker cause a crash while attempting to shut
+    // down the COM multithreaded apartment. By instantiating EnsureMTA, we hold
+    // an additional reference to the MTA that should prevent this race, since
+    // the MTA will remain alive until shutdown.
+    EnsureMTA ensureMTA;
+  }
+
+  RefPtr<IFileDialog> dialog;
+  if (mMode != modeSave) {
+    if (FAILED(CoCreateInstance(CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC,
+                                IID_IFileOpenDialog,
+                                getter_AddRefs(dialog)))) {
+      aWasInitError = true;
+      return false;
+    }
+  } else {
+    if (FAILED(CoCreateInstance(CLSID_FileSaveDialog, nullptr, CLSCTX_INPROC,
+                                IID_IFileSaveDialog,
+                                getter_AddRefs(dialog)))) {
+      aWasInitError = true;
+      return false;
+    }
+  }
+  aWasInitError = false;
+
+  // hook up event callbacks
+  dialog->Advise(this, &mFDECookie);
+
+  // options
+
+  FILEOPENDIALOGOPTIONS fos = 0;
+  fos |= FOS_SHAREAWARE | FOS_OVERWRITEPROMPT |
+         FOS_FORCEFILESYSTEM;
+
+  // Handle add to recent docs settings
+  if (IsPrivacyModeEnabled() || !mAddToRecentDocs) {
+    fos |= FOS_DONTADDTORECENT;
+  }
+
+  // Msdn claims FOS_NOCHANGEDIR is not needed. We'll add this
+  // just in case.
+  AutoRestoreWorkingPath arw;
+
+  // mode specific
+  switch(mMode) {
+    case modeOpen:
+      fos |= FOS_FILEMUSTEXIST;
+      break;
+
+    case modeOpenMultiple:
+      fos |= FOS_FILEMUSTEXIST | FOS_ALLOWMULTISELECT;
+      break;
+
+    case modeSave:
+      fos |= FOS_NOREADONLYRETURN;
+      // Don't follow shortcuts when saving a shortcut, this can be used
+      // to trick users (bug 271732)
+      if (IsDefaultPathLink())
+        fos |= FOS_NODEREFERENCELINKS;
+      break;
+  }
+
+  dialog->SetOptions(fos);
+
+  // initial strings
+
+  // title
+  dialog->SetTitle(mTitle.get());
+
+  // default filename
+  if (!mDefaultFilename.IsEmpty()) {
+    dialog->SetFileName(mDefaultFilename.get());
+  }
+  
+  NS_NAMED_LITERAL_STRING(htmExt, "html");
+
+  // default extension to append to new files
+  if (!mDefaultExtension.IsEmpty()) {
+    dialog->SetDefaultExtension(mDefaultExtension.get());
+  } else if (IsDefaultPathHtml()) {
+    dialog->SetDefaultExtension(htmExt.get());
+  }
+
+  // initial location
+  if (!aInitialDir.IsEmpty()) {
+    RefPtr<IShellItem> folder;
+    if (SUCCEEDED(
+          WinUtils::SHCreateItemFromParsingName(aInitialDir.get(), nullptr,
+                                                IID_IShellItem,
+                                                getter_AddRefs(folder)))) {
+      dialog->SetFolder(folder);
+    }
+  }
+
+  // filter types and the default index
+  if (!mComFilterList.IsEmpty()) {
+    dialog->SetFileTypes(mComFilterList.Length(), mComFilterList.get());
+    dialog->SetFileTypeIndex(mSelectedType);
+  }
+
+  // display
+
+  {
+    AutoDestroyTmpWindow adtw((HWND)(mParentWidget.get() ?
+      mParentWidget->GetNativeData(NS_NATIVE_TMP_WINDOW) : nullptr));
+    AutoTimerCallbackCancel atcc(this, PickerCallbackTimerFunc);
+    AutoWidgetPickerState awps(mParentWidget);
+
+    if (FAILED(dialog->Show(adtw.get()))) {
+      dialog->Unadvise(mFDECookie);
+      return false;
+    }
+    dialog->Unadvise(mFDECookie);
+  }
+
+  // results
+
+  // Remember what filter type the user selected
+  UINT filterIdxResult;
+  if (SUCCEEDED(dialog->GetFileTypeIndex(&filterIdxResult))) {
+    mSelectedType = (int16_t)filterIdxResult;
+  }
+
+  // single selection
+  if (mMode != modeOpenMultiple) {
+    RefPtr<IShellItem> item;
+    if (FAILED(dialog->GetResult(getter_AddRefs(item))) || !item)
+      return false;
+    return WinUtils::GetShellItemPath(item, mUnicodeFile);
+  }
+
+  // multiple selection
+  RefPtr<IFileOpenDialog> openDlg;
+  dialog->QueryInterface(IID_IFileOpenDialog, getter_AddRefs(openDlg));
+  if (!openDlg) {
+    // should not happen
+    return false;
+  }
+
+  RefPtr<IShellItemArray> items;
+  if (FAILED(openDlg->GetResults(getter_AddRefs(items))) || !items) {
+    return false;
+  }
+
+  DWORD count = 0;
+  items->GetCount(&count);
+  for (unsigned int idx = 0; idx < count; idx++) {
+    RefPtr<IShellItem> item;
+    nsAutoString str;
+    if (SUCCEEDED(items->GetItemAt(idx, getter_AddRefs(item)))) {
+      if (!WinUtils::GetShellItemPath(item, str))
+        continue;
+      nsCOMPtr<nsIFile> file = do_CreateInstance("@mozilla.org/file/local;1");
+      if (file && NS_SUCCEEDED(file->InitWithPath(str)))
+        mFiles.AppendObject(file);
+    }
+  }
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// nsIFilePicker impl.
+
+NS_IMETHODIMP
+nsFilePicker::ShowW(int16_t *aReturnVal)
+{
+  NS_ENSURE_ARG_POINTER(aReturnVal);
+
+  *aReturnVal = returnCancel;
+
+  AutoSuppressEvents supress(mParentWidget);
+
+  nsAutoString initialDir;
+  if (mDisplayDirectory)
+    mDisplayDirectory->GetPath(initialDir);
+
+  // If no display directory, re-use the last one.
+  if(initialDir.IsEmpty()) {
+    // Allocate copy of last used dir.
+    initialDir = mLastUsedUnicodeDirectory;
+  }
+
+  // Clear previous file selections
+  mUnicodeFile.Truncate();
+  mFiles.Clear();
+
+  // On Win10, the picker doesn't support per-monitor DPI, so we open it
+  // with our context set temporarily to system-dpi-aware
+  WinUtils::AutoSystemDpiAware dpiAwareness;
+
+  // Launch the XP file/folder picker on XP and as a fallback on Vista+. 
+  // The CoCreateInstance call to CLSID_FileOpenDialog fails with "(0x80040111)
+  // ClassFactory cannot supply requested class" when the checkbox for
+  // Disable Visual Themes is on in the compatability tab within the shortcut
+  // properties.
+  bool result = false, wasInitError = true;
+  if (mMode == modeGetFolder) {
+    if (IsVistaOrLater())
+      result = ShowFolderPicker(initialDir, wasInitError);
+    if (!result && wasInitError)
+      result = ShowXPFolderPicker(initialDir);
+  } else {
+    if (IsVistaOrLater())
+      result = ShowFilePicker(initialDir, wasInitError);
+    if (!result && wasInitError)
+      result = ShowXPFilePicker(initialDir);
+  }
+
+  // exit, and return returnCancel in aReturnVal
+  if (!result)
+    return NS_OK;
+
+  RememberLastUsedDirectory();
+
+  int16_t retValue = returnOK;
+  if (mMode == modeSave) {
+    // Windows does not return resultReplace, we must check if file
+    // already exists.
+    nsCOMPtr<nsIFile> file(do_CreateInstance("@mozilla.org/file/local;1"));
+    bool flag = false;
+    if (file && NS_SUCCEEDED(file->InitWithPath(mUnicodeFile)) &&
+        NS_SUCCEEDED(file->Exists(&flag)) && flag) {
+      retValue = returnReplace;
+    }
+  }
+
+  *aReturnVal = retValue;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::Show(int16_t *aReturnVal)
+{
+  return ShowW(aReturnVal);
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetFile(nsIFile **aFile)
+{
+  NS_ENSURE_ARG_POINTER(aFile);
+  *aFile = nullptr;
+
+  if (mUnicodeFile.IsEmpty())
+      return NS_OK;
+
+  nsCOMPtr<nsIFile> file(do_CreateInstance("@mozilla.org/file/local;1"));
+    
+  NS_ENSURE_TRUE(file, NS_ERROR_FAILURE);
+
+  file->InitWithPath(mUnicodeFile);
+
+  NS_ADDREF(*aFile = file);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetFileURL(nsIURI **aFileURL)
+{
+  *aFileURL = nullptr;
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = GetFile(getter_AddRefs(file));
+  if (!file)
+    return rv;
+
+  return NS_NewFileURI(aFileURL, file);
+}
+
+NS_IMETHODIMP
+nsFilePicker::GetFiles(nsISimpleEnumerator **aFiles)
+{
+  NS_ENSURE_ARG_POINTER(aFiles);
+  return NS_NewArrayEnumerator(aFiles, mFiles);
+}
+
+// Get the file + path
+NS_IMETHODIMP
+nsBaseWinFilePicker::SetDefaultString(const nsAString& aString)
+{
+  mDefaultFilePath = aString;
+
+  // First, make sure the file name is not too long.
+  int32_t nameLength;
+  int32_t nameIndex = mDefaultFilePath.RFind("\\");
+  if (nameIndex == kNotFound)
+    nameIndex = 0;
+  else
+    nameIndex ++;
+  nameLength = mDefaultFilePath.Length() - nameIndex;
+  mDefaultFilename.Assign(Substring(mDefaultFilePath, nameIndex));
+  
+  if (nameLength > MAX_PATH) {
+    int32_t extIndex = mDefaultFilePath.RFind(".");
+    if (extIndex == kNotFound)
+      extIndex = mDefaultFilePath.Length();
+
+    // Let's try to shave the needed characters from the name part.
+    int32_t charsToRemove = nameLength - MAX_PATH;
+    if (extIndex - nameIndex >= charsToRemove) {
+      mDefaultFilePath.Cut(extIndex - charsToRemove, charsToRemove);
+    }
+  }
+
+  // Then, we need to replace illegal characters. At this stage, we cannot
+  // replace the backslash as the string might represent a file path.
+  mDefaultFilePath.ReplaceChar(FILE_ILLEGAL_CHARACTERS, '-');
+  mDefaultFilename.ReplaceChar(FILE_ILLEGAL_CHARACTERS, '-');
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBaseWinFilePicker::GetDefaultString(nsAString& aString)
+{
+  return NS_ERROR_FAILURE;
+}
+
+// The default extension to use for files
+NS_IMETHODIMP
+nsBaseWinFilePicker::GetDefaultExtension(nsAString& aExtension)
+{
+  aExtension = mDefaultExtension;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBaseWinFilePicker::SetDefaultExtension(const nsAString& aExtension)
+{
+  mDefaultExtension = aExtension;
+  return NS_OK;
+}
+
+// Set the filter index
+NS_IMETHODIMP
+nsFilePicker::GetFilterIndex(int32_t *aFilterIndex)
+{
+  // Windows' filter index is 1-based, we use a 0-based system.
+  *aFilterIndex = mSelectedType - 1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFilePicker::SetFilterIndex(int32_t aFilterIndex)
+{
+  // Windows' filter index is 1-based, we use a 0-based system.
+  mSelectedType = aFilterIndex + 1;
+  return NS_OK;
+}
+
+void
+nsFilePicker::InitNative(nsIWidget *aParent,
+                         const nsAString& aTitle)
+{
+  mParentWidget = aParent;
+  mTitle.Assign(aTitle);
+}
+
+void 
+nsFilePicker::GetQualifiedPath(const wchar_t *aInPath, nsString &aOutPath)
+{
+  // Prefer a qualified path over a non qualified path.
+  // Things like c:file.txt would be accepted in Win XP but would later
+  // fail to open from the download manager.
+  wchar_t qualifiedFileBuffer[MAX_PATH];
+  if (PathSearchAndQualifyW(aInPath, qualifiedFileBuffer, MAX_PATH)) {
+    aOutPath.Assign(qualifiedFileBuffer);
+  } else {
+    aOutPath.Assign(aInPath);
+  }
+}
+
+void
+nsFilePicker::AppendXPFilter(const nsAString& aTitle, const nsAString& aFilter)
+{
+  mFilterList.Append(aTitle);
+  mFilterList.Append(char16_t('\0'));
+
+  if (aFilter.EqualsLiteral("..apps"))
+    mFilterList.AppendLiteral("*.exe;*.com");
+  else
+  {
+    nsAutoString filter(aFilter);
+    filter.StripWhitespace();
+    if (filter.EqualsLiteral("*"))
+      filter.AppendLiteral(".*");
+    mFilterList.Append(filter);
+  }
+
+  mFilterList.Append(char16_t('\0'));
+}
+
+NS_IMETHODIMP
+nsFilePicker::AppendFilter(const nsAString& aTitle, const nsAString& aFilter)
+{
+  if (IsVistaOrLater()) {
+    mComFilterList.Append(aTitle, aFilter);
+  } else {
+    AppendXPFilter(aTitle, aFilter);
+  }
+  return NS_OK;
+}
+
+void
+nsFilePicker::RememberLastUsedDirectory()
+{
+  nsCOMPtr<nsIFile> file(do_CreateInstance("@mozilla.org/file/local;1"));
+  if (!file || NS_FAILED(file->InitWithPath(mUnicodeFile))) {
+    NS_WARNING("RememberLastUsedDirectory failed to init file path.");
+    return;
+  }
+
+  nsCOMPtr<nsIFile> dir;
+  nsAutoString newDir;
+  if (NS_FAILED(file->GetParent(getter_AddRefs(dir))) ||
+      !(mDisplayDirectory = do_QueryInterface(dir)) ||
+      NS_FAILED(mDisplayDirectory->GetPath(newDir)) ||
+      newDir.IsEmpty()) {
+    NS_WARNING("RememberLastUsedDirectory failed to get parent directory.");
+    return;
+  }
+
+  if (mLastUsedUnicodeDirectory) {
+    free(mLastUsedUnicodeDirectory);
+    mLastUsedUnicodeDirectory = nullptr;
+  }
+  mLastUsedUnicodeDirectory = ToNewUnicode(newDir);
+}
+
+bool
+nsFilePicker::IsPrivacyModeEnabled()
+{
+  return mLoadContext && mLoadContext->UsePrivateBrowsing();
+}
+
+bool
+nsFilePicker::IsDefaultPathLink()
+{
+  NS_ConvertUTF16toUTF8 ext(mDefaultFilePath);
+  ext.Trim(" .", false, true); // watch out for trailing space and dots
+  ToLowerCase(ext);
+  if (StringEndsWith(ext, NS_LITERAL_CSTRING(".lnk")) ||
+      StringEndsWith(ext, NS_LITERAL_CSTRING(".pif")) ||
+      StringEndsWith(ext, NS_LITERAL_CSTRING(".url")))
+    return true;
+  return false;
+}
+
+bool
+nsFilePicker::IsDefaultPathHtml()
+{
+  int32_t extIndex = mDefaultFilePath.RFind(".");
+  if (extIndex >= 0) {
+    nsAutoString ext;
+    mDefaultFilePath.Right(ext, mDefaultFilePath.Length() - extIndex);
+    if (ext.LowerCaseEqualsLiteral(".htm")  ||
+        ext.LowerCaseEqualsLiteral(".html") ||
+        ext.LowerCaseEqualsLiteral(".shtml"))
+      return true;
+  }
+  return false;
+}
+
+void
+nsFilePicker::ComDlgFilterSpec::Append(const nsAString& aTitle, const nsAString& aFilter)
+{
+  COMDLG_FILTERSPEC* pSpecForward = mSpecList.AppendElement();
+  if (!pSpecForward) {
+    NS_WARNING("mSpecList realloc failed.");
+    return;
+  }
+  memset(pSpecForward, 0, sizeof(*pSpecForward));
+  nsString* pStr = mStrings.AppendElement(aTitle);
+  if (!pStr) {
+    NS_WARNING("mStrings.AppendElement failed.");
+    return;
+  }
+  pSpecForward->pszName = pStr->get();
+  pStr = mStrings.AppendElement(aFilter);
+  if (!pStr) {
+    NS_WARNING("mStrings.AppendElement failed.");
+    return;
+  }
+  if (aFilter.EqualsLiteral("..apps"))
+    pStr->AssignLiteral("*.exe;*.com");
+  else {
+    pStr->StripWhitespace();
+    if (pStr->EqualsLiteral("*"))
+      pStr->AppendLiteral(".*");
+  }
+  pSpecForward->pszSpec = pStr->get();
+}