Add m-esr52 at 52.6.0

4 files changed, 1645 insertions, 0 deletions

diff --git a/uriloader/exthandler/win/nsMIMEInfoWin.cpp b/uriloader/exthandler/win/nsMIMEInfoWin.cpp
new file mode 100644
index 000000000..2c7171c87
--- /dev/null
+++ b/uriloader/exthandler/win/nsMIMEInfoWin.cpp
@@ -0,0 +1,883 @@
+/* -*- Mode: C++; tab-width: 3; 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 "nsArrayEnumerator.h"
+#include "nsCOMArray.h"
+#include "nsLocalFile.h"
+#include "nsMIMEInfoWin.h"
+#include "nsNetUtil.h"
+#include <windows.h>
+#include <shellapi.h>
+#include "nsAutoPtr.h"
+#include "nsIMutableArray.h"
+#include "nsTArray.h"
+#include "shlobj.h"
+#include "windows.h"
+#include "nsIWindowsRegKey.h"
+#include "nsIProcess.h"
+#include "nsUnicharUtils.h"
+#include "nsITextToSubURI.h"
+#include "nsVariant.h"
+#include "mozilla/UniquePtrExtensions.h"
+
+#define RUNDLL32_EXE L"\\rundll32.exe"
+
+
+NS_IMPL_ISUPPORTS_INHERITED(nsMIMEInfoWin, nsMIMEInfoBase, nsIPropertyBag)
+
+nsMIMEInfoWin::~nsMIMEInfoWin()
+{
+}
+
+nsresult
+nsMIMEInfoWin::LaunchDefaultWithFile(nsIFile* aFile)
+{
+  // Launch the file, unless it is an executable.
+  bool executable = true;
+  aFile->IsExecutable(&executable);
+  if (executable)
+    return NS_ERROR_FAILURE;
+
+  return aFile->Launch();
+}
+
+NS_IMETHODIMP
+nsMIMEInfoWin::LaunchWithFile(nsIFile* aFile)
+{
+  nsresult rv;
+
+  // it doesn't make any sense to call this on protocol handlers
+  NS_ASSERTION(mClass == eMIMEInfo,
+               "nsMIMEInfoBase should have mClass == eMIMEInfo");
+
+  if (mPreferredAction == useSystemDefault) {
+    return LaunchDefaultWithFile(aFile);
+  }
+
+  if (mPreferredAction == useHelperApp) {
+    if (!mPreferredApplication)
+      return NS_ERROR_FILE_NOT_FOUND;
+
+    // at the moment, we only know how to hand files off to local handlers
+    nsCOMPtr<nsILocalHandlerApp> localHandler = 
+      do_QueryInterface(mPreferredApplication, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIFile> executable;
+    rv = localHandler->GetExecutable(getter_AddRefs(executable));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString path;
+    aFile->GetPath(path);
+
+    // Deal with local dll based handlers
+    nsCString filename;
+    executable->GetNativeLeafName(filename);
+    if (filename.Length() > 4) {
+      nsCString extension(Substring(filename, filename.Length() - 4, 4));
+
+      if (extension.LowerCaseEqualsLiteral(".dll")) {
+        nsAutoString args;
+
+        // executable is rundll32, everything else is a list of parameters, 
+        // including the dll handler.
+        if (!GetDllLaunchInfo(executable, aFile, args, false))
+          return NS_ERROR_INVALID_ARG;
+
+        WCHAR rundll32Path[MAX_PATH + sizeof(RUNDLL32_EXE) / sizeof(WCHAR) + 1] = {L'\0'};
+        if (!GetSystemDirectoryW(rundll32Path, MAX_PATH)) {
+          return NS_ERROR_FILE_NOT_FOUND;
+        }
+        lstrcatW(rundll32Path, RUNDLL32_EXE);
+
+        SHELLEXECUTEINFOW seinfo;
+        memset(&seinfo, 0, sizeof(seinfo));
+        seinfo.cbSize = sizeof(SHELLEXECUTEINFOW);
+        seinfo.fMask  = 0;
+        seinfo.hwnd   = nullptr;
+        seinfo.lpVerb = nullptr;
+        seinfo.lpFile = rundll32Path;
+        seinfo.lpParameters =  args.get();
+        seinfo.lpDirectory  = nullptr;
+        seinfo.nShow  = SW_SHOWNORMAL;
+        if (ShellExecuteExW(&seinfo))
+          return NS_OK;
+
+        switch ((LONG_PTR)seinfo.hInstApp) {
+          case 0:
+          case SE_ERR_OOM:
+            return NS_ERROR_OUT_OF_MEMORY;
+          case SE_ERR_ACCESSDENIED:
+            return NS_ERROR_FILE_ACCESS_DENIED;
+          case SE_ERR_ASSOCINCOMPLETE:
+          case SE_ERR_NOASSOC:
+            return NS_ERROR_UNEXPECTED;
+          case SE_ERR_DDEBUSY:
+          case SE_ERR_DDEFAIL:
+          case SE_ERR_DDETIMEOUT:
+            return NS_ERROR_NOT_AVAILABLE;
+          case SE_ERR_DLLNOTFOUND:
+            return NS_ERROR_FAILURE;
+          case SE_ERR_SHARE:
+            return NS_ERROR_FILE_IS_LOCKED;
+          default:
+            switch(GetLastError()) {
+              case ERROR_FILE_NOT_FOUND:
+                return NS_ERROR_FILE_NOT_FOUND;
+              case ERROR_PATH_NOT_FOUND:
+                return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+              case ERROR_BAD_FORMAT:
+                return NS_ERROR_FILE_CORRUPTED;
+            }
+
+        }
+        return NS_ERROR_FILE_EXECUTION_FAILED;
+      }
+    }
+    return LaunchWithIProcess(executable, path);
+  }
+
+  return NS_ERROR_INVALID_ARG;
+}
+
+NS_IMETHODIMP
+nsMIMEInfoWin::GetHasDefaultHandler(bool * _retval)
+{
+  // We have a default application if we have a description
+  // We can ShellExecute anything; however, callers are probably interested if
+  // there is really an application associated with this type of file
+  *_retval = !mDefaultAppDescription.IsEmpty();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMIMEInfoWin::GetEnumerator(nsISimpleEnumerator* *_retval)
+{
+  nsCOMArray<nsIVariant> properties;
+
+  nsCOMPtr<nsIVariant> variant;
+  GetProperty(NS_LITERAL_STRING("defaultApplicationIconURL"), getter_AddRefs(variant));
+  if (variant)
+    properties.AppendObject(variant);
+
+  GetProperty(NS_LITERAL_STRING("customApplicationIconURL"), getter_AddRefs(variant));
+  if (variant)
+    properties.AppendObject(variant);
+
+  return NS_NewArrayEnumerator(_retval, properties);
+}
+
+static nsresult GetIconURLVariant(nsIFile* aApplication, nsIVariant* *_retval)
+{
+  nsAutoCString fileURLSpec;
+  NS_GetURLSpecFromFile(aApplication, fileURLSpec);
+  nsAutoCString iconURLSpec; iconURLSpec.AssignLiteral("moz-icon://");
+  iconURLSpec += fileURLSpec;
+  RefPtr<nsVariant> writable(new nsVariant());
+  writable->SetAsAUTF8String(iconURLSpec);
+  writable.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMIMEInfoWin::GetProperty(const nsAString& aName, nsIVariant* *_retval)
+{
+  nsresult rv;
+  if (mDefaultApplication && aName.EqualsLiteral(PROPERTY_DEFAULT_APP_ICON_URL)) {
+    rv = GetIconURLVariant(mDefaultApplication, _retval);
+    NS_ENSURE_SUCCESS(rv, rv);    
+  } else if (mPreferredApplication && 
+             aName.EqualsLiteral(PROPERTY_CUSTOM_APP_ICON_URL)) {
+    nsCOMPtr<nsILocalHandlerApp> localHandler =
+      do_QueryInterface(mPreferredApplication, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    
+    nsCOMPtr<nsIFile> executable;
+    rv = localHandler->GetExecutable(getter_AddRefs(executable));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = GetIconURLVariant(executable, _retval);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+// this implementation was pretty much copied verbatime from 
+// Tony Robinson's code in nsExternalProtocolWin.cpp
+nsresult
+nsMIMEInfoWin::LoadUriInternal(nsIURI * aURL)
+{
+  nsresult rv = NS_OK;
+
+  // 1. Find the default app for this protocol
+  // 2. Set up the command line
+  // 3. Launch the app.
+
+  // For now, we'll just cheat essentially, check for the command line
+  // then just call ShellExecute()!
+
+  if (aURL)
+  {
+    // extract the url spec from the url
+    nsAutoCString urlSpec;
+    aURL->GetAsciiSpec(urlSpec);
+ 
+    // Unescape non-ASCII characters in the URL
+    nsAutoCString urlCharset;
+    nsAutoString utf16Spec;
+    rv = aURL->GetOriginCharset(urlCharset);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsITextToSubURI> textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (NS_FAILED(textToSubURI->UnEscapeNonAsciiURI(urlCharset, urlSpec, utf16Spec))) {
+      CopyASCIItoUTF16(urlSpec, utf16Spec);
+    }
+
+    static const wchar_t cmdVerb[] = L"open";
+    SHELLEXECUTEINFOW sinfo;
+    memset(&sinfo, 0, sizeof(sinfo));
+    sinfo.cbSize   = sizeof(sinfo);
+    sinfo.fMask    = SEE_MASK_FLAG_DDEWAIT |
+      SEE_MASK_FLAG_NO_UI;
+    sinfo.hwnd     = nullptr;
+    sinfo.lpVerb   = (LPWSTR)&cmdVerb;
+    sinfo.nShow    = SW_SHOWNORMAL;
+    
+    LPITEMIDLIST pidl = nullptr;
+    SFGAOF sfgao;
+    
+    // Bug 394974
+    if (SUCCEEDED(SHParseDisplayName(utf16Spec.get(), nullptr,
+                                     &pidl, 0, &sfgao))) {
+      sinfo.lpIDList = pidl;
+      sinfo.fMask |= SEE_MASK_INVOKEIDLIST;
+    } else {
+      // SHParseDisplayName failed. Bailing out as work around for
+      // Microsoft Security Bulletin MS07-061
+      rv = NS_ERROR_FAILURE;
+    }
+    if (NS_SUCCEEDED(rv)) {
+      BOOL result = ShellExecuteExW(&sinfo);
+      if (!result || ((LONG_PTR)sinfo.hInstApp) < 32)
+        rv = NS_ERROR_FAILURE;
+    }
+    if (pidl)
+      CoTaskMemFree(pidl);
+  }
+  
+  return rv;
+}
+
+// Given a path to a local file, return its nsILocalHandlerApp instance.
+bool nsMIMEInfoWin::GetLocalHandlerApp(const nsAString& aCommandHandler,
+                                         nsCOMPtr<nsILocalHandlerApp>& aApp)
+{
+  nsCOMPtr<nsIFile> locfile;
+  nsresult rv = 
+    NS_NewLocalFile(aCommandHandler, true, getter_AddRefs(locfile));
+  if (NS_FAILED(rv))
+    return false;
+
+  aApp = do_CreateInstance("@mozilla.org/uriloader/local-handler-app;1");
+  if (!aApp) 
+    return false;
+
+  aApp->SetExecutable(locfile);
+  return true;
+}
+
+// Return the cleaned up file path associated with a command verb 
+// located in root/Applications.
+bool nsMIMEInfoWin::GetAppsVerbCommandHandler(const nsAString& appExeName,
+                                                nsAString& applicationPath,
+                                                bool edit)
+{
+  nsCOMPtr<nsIWindowsRegKey> appKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!appKey) 
+    return false; 
+
+  // HKEY_CLASSES_ROOT\Applications\iexplore.exe
+  nsAutoString applicationsPath;
+  applicationsPath.AppendLiteral("Applications\\");
+  applicationsPath.Append(appExeName);
+
+  nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             applicationsPath,
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv)) 
+    return false;
+
+  // Check for the NoOpenWith flag, if it exists
+  uint32_t value;
+  if (NS_SUCCEEDED(appKey->ReadIntValue(
+      NS_LITERAL_STRING("NoOpenWith"), &value)) &&
+      value == 1)
+    return false;
+
+  nsAutoString dummy;
+  if (NS_SUCCEEDED(appKey->ReadStringValue(
+        NS_LITERAL_STRING("NoOpenWith"), dummy)))
+    return false;
+
+  appKey->Close();
+
+  // HKEY_CLASSES_ROOT\Applications\iexplore.exe\shell\open\command
+  applicationsPath.AssignLiteral("Applications\\");
+  applicationsPath.Append(appExeName);
+  if (!edit)
+    applicationsPath.AppendLiteral("\\shell\\open\\command");
+  else
+    applicationsPath.AppendLiteral("\\shell\\edit\\command");
+
+
+  rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                    applicationsPath,
+                    nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv)) 
+    return false;
+
+  nsAutoString appFilesystemCommand;
+  if (NS_SUCCEEDED(appKey->ReadStringValue(EmptyString(), 
+                                           appFilesystemCommand))) {
+    
+    // Expand environment vars, clean up any misc.
+    if (!nsLocalFile::CleanupCmdHandlerPath(appFilesystemCommand))
+      return false;
+    
+    applicationPath = appFilesystemCommand;
+    return true;
+  }
+  return false;
+}
+
+// Return a fully populated command string based on
+// passing information. Used in launchWithFile to trace
+// back to the full handler path based on the dll.
+// (dll, targetfile, return args, open/edit)
+bool nsMIMEInfoWin::GetDllLaunchInfo(nsIFile * aDll,
+                                       nsIFile * aFile,
+                                       nsAString& args,
+                                       bool edit)
+{
+  if (!aDll || !aFile) 
+    return false;
+
+  nsString appExeName;
+  aDll->GetLeafName(appExeName);
+
+  nsCOMPtr<nsIWindowsRegKey> appKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!appKey) 
+    return false; 
+
+  // HKEY_CLASSES_ROOT\Applications\iexplore.exe
+  nsAutoString applicationsPath;
+  applicationsPath.AppendLiteral("Applications\\");
+  applicationsPath.Append(appExeName);
+
+  nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             applicationsPath,
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+    return false;
+
+  // Check for the NoOpenWith flag, if it exists
+  uint32_t value;
+  rv = appKey->ReadIntValue(NS_LITERAL_STRING("NoOpenWith"), &value);
+  if (NS_SUCCEEDED(rv) && value == 1)
+    return false;
+
+  nsAutoString dummy;
+  if (NS_SUCCEEDED(appKey->ReadStringValue(NS_LITERAL_STRING("NoOpenWith"), 
+                                           dummy)))
+    return false;
+
+  appKey->Close();
+
+  // HKEY_CLASSES_ROOT\Applications\iexplore.exe\shell\open\command
+  applicationsPath.AssignLiteral("Applications\\");
+  applicationsPath.Append(appExeName);
+  if (!edit)
+    applicationsPath.AppendLiteral("\\shell\\open\\command");
+  else
+    applicationsPath.AppendLiteral("\\shell\\edit\\command");
+
+  rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                    applicationsPath,
+                    nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+    return false;
+
+  nsAutoString appFilesystemCommand;
+  if (NS_SUCCEEDED(appKey->ReadStringValue(EmptyString(),
+                                           appFilesystemCommand))) {
+    // Replace embedded environment variables.
+    uint32_t bufLength = 
+      ::ExpandEnvironmentStringsW(appFilesystemCommand.get(),
+                                  L"", 0);
+    if (bufLength == 0) // Error
+      return false;
+
+    auto destination = mozilla::MakeUniqueFallible<wchar_t[]>(bufLength);
+    if (!destination)
+      return false;
+    if (!::ExpandEnvironmentStringsW(appFilesystemCommand.get(),
+                                     destination.get(),
+                                     bufLength))
+      return false;
+
+    appFilesystemCommand.Assign(destination.get());
+
+    // C:\Windows\System32\rundll32.exe "C:\Program Files\Windows 
+    // Photo Gallery\PhotoViewer.dll", ImageView_Fullscreen %1
+    nsAutoString params;
+    NS_NAMED_LITERAL_STRING(rundllSegment, "rundll32.exe ");
+    int32_t index = appFilesystemCommand.Find(rundllSegment);
+    if (index > kNotFound) {
+      params.Append(Substring(appFilesystemCommand,
+                    index + rundllSegment.Length()));
+    } else {
+      params.Append(appFilesystemCommand);
+    }
+
+    // check to make sure we have a %1 and fill it
+    NS_NAMED_LITERAL_STRING(percentOneParam, "%1");
+    index = params.Find(percentOneParam);
+    if (index == kNotFound) // no parameter
+      return false;
+
+    nsString target;
+    aFile->GetTarget(target);
+    params.Replace(index, 2, target);
+
+    args = params;
+
+    return true;
+  }
+  return false;
+}
+
+// Return the cleaned up file path associated with a progid command 
+// verb located in root.
+bool nsMIMEInfoWin::GetProgIDVerbCommandHandler(const nsAString& appProgIDName,
+                                                  nsAString& applicationPath,
+                                                  bool edit)
+{
+  nsCOMPtr<nsIWindowsRegKey> appKey =
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!appKey) 
+    return false; 
+
+  nsAutoString appProgId(appProgIDName);
+
+  // HKEY_CLASSES_ROOT\Windows.XPSReachViewer\shell\open\command
+  if (!edit)
+    appProgId.AppendLiteral("\\shell\\open\\command");
+  else
+    appProgId.AppendLiteral("\\shell\\edit\\command");
+
+  nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             appProgId,
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+    return false;
+
+  nsAutoString appFilesystemCommand;
+  if (NS_SUCCEEDED(appKey->ReadStringValue(EmptyString(), appFilesystemCommand))) {
+    
+    // Expand environment vars, clean up any misc.
+    if (!nsLocalFile::CleanupCmdHandlerPath(appFilesystemCommand))
+      return false;
+    
+    applicationPath = appFilesystemCommand;
+    return true;
+  }
+  return false;
+}
+
+// Helper routine used in tracking app lists. Converts path
+// entries to lower case and stores them in the trackList array.
+void nsMIMEInfoWin::ProcessPath(nsCOMPtr<nsIMutableArray>& appList,
+                                nsTArray<nsString>& trackList,
+                                const nsAString& appFilesystemCommand)
+{
+  nsAutoString lower(appFilesystemCommand);
+  ToLowerCase(lower);
+
+  // Don't include firefox.exe in the list
+  WCHAR exe[MAX_PATH+1];
+  uint32_t len = GetModuleFileNameW(nullptr, exe, MAX_PATH);
+  if (len < MAX_PATH && len != 0) {
+    uint32_t index = lower.Find(exe);
+    if (index != -1)
+      return;
+  }
+
+  nsCOMPtr<nsILocalHandlerApp> aApp;
+  if (!GetLocalHandlerApp(appFilesystemCommand, aApp))
+    return;
+
+  // Save in our main tracking arrays
+  appList->AppendElement(aApp, false);
+  trackList.AppendElement(lower);
+}
+
+// Helper routine that handles a compare between a path
+// and an array of paths.
+static bool IsPathInList(nsAString& appPath,
+                           nsTArray<nsString>& trackList)
+{
+  // trackList data is always lowercase, see ProcessPath
+  // above.
+  nsAutoString tmp(appPath);
+  ToLowerCase(tmp);
+
+  for (uint32_t i = 0; i < trackList.Length(); i++) {
+    if (tmp.Equals(trackList[i]))
+      return true;
+  }
+  return false;
+}
+
+/** 
+ * Returns a list of nsILocalHandlerApp objects containing local 
+ * handlers associated with this mimeinfo. Implemented per 
+ * platform using information in this object to generate the
+ * best list. Typically used for an "open with" style user 
+ * option.
+ * 
+ * @return nsIArray of nsILocalHandlerApp
+ */
+NS_IMETHODIMP
+nsMIMEInfoWin::GetPossibleLocalHandlers(nsIArray **_retval)
+{
+  nsresult rv;
+
+  *_retval = nullptr;
+
+  nsCOMPtr<nsIMutableArray> appList =
+    do_CreateInstance("@mozilla.org/array;1");
+
+  if (!appList)
+    return NS_ERROR_FAILURE;
+
+  nsTArray<nsString> trackList;
+
+  nsAutoCString fileExt;
+  GetPrimaryExtension(fileExt);
+
+  nsCOMPtr<nsIWindowsRegKey> regKey =
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!regKey) 
+    return NS_ERROR_FAILURE; 
+  nsCOMPtr<nsIWindowsRegKey> appKey =
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!appKey) 
+    return NS_ERROR_FAILURE; 
+
+  nsAutoString workingRegistryPath;
+
+  bool extKnown = false;
+  if (fileExt.IsEmpty()) {
+    extKnown = true;
+    // Mime type discovery is possible in some cases, through 
+    // HKEY_CLASSES_ROOT\MIME\Database\Content Type, however, a number
+    // of file extensions related to mime type are simply not defined,
+    // (application/rss+xml & application/atom+xml are good examples)
+    // in which case we can only provide a generic list.
+    nsAutoCString mimeType;
+    GetMIMEType(mimeType);
+    if (!mimeType.IsEmpty()) {
+      workingRegistryPath.AppendLiteral("MIME\\Database\\Content Type\\");
+      workingRegistryPath.Append(NS_ConvertASCIItoUTF16(mimeType));
+            
+      rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                        workingRegistryPath,
+                        nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+      if(NS_SUCCEEDED(rv)) {
+        nsAutoString mimeFileExt;
+        if (NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(), mimeFileExt))) {
+          CopyUTF16toUTF8(mimeFileExt, fileExt);
+          extKnown = false;
+        }
+      }
+    }
+  }
+
+  nsAutoString fileExtToUse;
+  if (fileExt.First() != '.')
+    fileExtToUse = char16_t('.');
+  fileExtToUse.Append(NS_ConvertUTF8toUTF16(fileExt));
+
+  // Note, the order in which these occur has an effect on the 
+  // validity of the resulting display list.
+
+  if (!extKnown) {
+    // 1) Get the default handler if it exists
+    workingRegistryPath = fileExtToUse;
+
+    rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                      workingRegistryPath,
+                      nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_SUCCEEDED(rv)) {
+      nsAutoString appProgId;
+      if (NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(), appProgId))) {
+        // Bug 358297 - ignore the embedded internet explorer handler
+        if (appProgId != NS_LITERAL_STRING("XPSViewer.Document")) {
+          nsAutoString appFilesystemCommand;
+          if (GetProgIDVerbCommandHandler(appProgId,
+                                          appFilesystemCommand,
+                                          false) &&
+              !IsPathInList(appFilesystemCommand, trackList)) {
+            ProcessPath(appList, trackList, appFilesystemCommand);
+          }
+        }
+      }
+      regKey->Close();
+    }
+
+
+    // 2) list HKEY_CLASSES_ROOT\.ext\OpenWithList
+    
+    workingRegistryPath = fileExtToUse;
+    workingRegistryPath.AppendLiteral("\\OpenWithList");
+
+    rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                      workingRegistryPath,
+                      nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_SUCCEEDED(rv)) {
+      uint32_t count = 0;
+      if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
+        for (uint32_t index = 0; index < count; index++) {
+          nsAutoString appName;
+          if (NS_FAILED(regKey->GetValueName(index, appName)))
+            continue;
+
+          // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
+          nsAutoString appFilesystemCommand;
+          if (!GetAppsVerbCommandHandler(appName,
+                                         appFilesystemCommand,
+                                         false) ||
+              IsPathInList(appFilesystemCommand, trackList))
+            continue;
+          ProcessPath(appList, trackList, appFilesystemCommand);
+        }
+      }
+      regKey->Close();
+    }
+
+
+    // 3) List HKEY_CLASSES_ROOT\.ext\OpenWithProgids, with the
+    // different step of resolving the progids for the command handler.
+
+    workingRegistryPath = fileExtToUse;
+    workingRegistryPath.AppendLiteral("\\OpenWithProgids");
+
+    rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                      workingRegistryPath,
+                      nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_SUCCEEDED(rv)) {
+      uint32_t count = 0;
+      if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
+        for (uint32_t index = 0; index < count; index++) {
+          // HKEY_CLASSES_ROOT\.ext\OpenWithProgids\Windows.XPSReachViewer
+          nsAutoString appProgId;
+          if (NS_FAILED(regKey->GetValueName(index, appProgId)))
+            continue;
+
+          nsAutoString appFilesystemCommand;
+          if (!GetProgIDVerbCommandHandler(appProgId,
+                                           appFilesystemCommand,
+                                           false) ||
+              IsPathInList(appFilesystemCommand, trackList))
+            continue;
+          ProcessPath(appList, trackList, appFilesystemCommand);
+        }
+      }
+      regKey->Close();
+    }
+
+
+    // 4) Add any non configured applications located in the MRU list
+
+    // HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion
+    // \Explorer\FileExts\.ext\OpenWithList
+    workingRegistryPath =
+      NS_LITERAL_STRING("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\");
+    workingRegistryPath += fileExtToUse;
+    workingRegistryPath.AppendLiteral("\\OpenWithList");
+
+    rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
+                      workingRegistryPath,
+                      nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_SUCCEEDED(rv)) {
+      uint32_t count = 0;
+      if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
+        for (uint32_t index = 0; index < count; index++) {
+          nsAutoString appName, appValue;
+          if (NS_FAILED(regKey->GetValueName(index, appName)))
+            continue;
+          if (appName.EqualsLiteral("MRUList"))
+            continue;
+          if (NS_FAILED(regKey->ReadStringValue(appName, appValue)))
+            continue;
+          
+          // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
+          nsAutoString appFilesystemCommand;
+          if (!GetAppsVerbCommandHandler(appValue,
+                                         appFilesystemCommand,
+                                         false) ||
+              IsPathInList(appFilesystemCommand, trackList))
+            continue;
+          ProcessPath(appList, trackList, appFilesystemCommand);
+        }
+      }
+    }
+    
+
+    // 5) Add any non configured progids in the MRU list, with the
+    // different step of resolving the progids for the command handler.
+    
+    // HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion
+    // \Explorer\FileExts\.ext\OpenWithProgids
+    workingRegistryPath =
+      NS_LITERAL_STRING("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\");
+    workingRegistryPath += fileExtToUse;
+    workingRegistryPath.AppendLiteral("\\OpenWithProgids");
+
+    regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
+                 workingRegistryPath,
+                 nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_SUCCEEDED(rv)) {
+      uint32_t count = 0;
+      if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
+        for (uint32_t index = 0; index < count; index++) {
+          nsAutoString appIndex, appProgId;
+          if (NS_FAILED(regKey->GetValueName(index, appProgId)))
+            continue;
+
+          nsAutoString appFilesystemCommand;
+          if (!GetProgIDVerbCommandHandler(appProgId,
+                                           appFilesystemCommand,
+                                           false) ||
+              IsPathInList(appFilesystemCommand, trackList))
+            continue;
+          ProcessPath(appList, trackList, appFilesystemCommand);
+        }
+      }
+      regKey->Close();
+    }
+
+
+    // 6) Check the perceived type value, and use this to lookup the perceivedtype
+    // open with list.
+    // http://msdn2.microsoft.com/en-us/library/aa969373.aspx
+
+    workingRegistryPath = fileExtToUse;
+
+    regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                 workingRegistryPath,
+                 nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_SUCCEEDED(rv)) {
+      nsAutoString perceivedType;
+      rv = regKey->ReadStringValue(NS_LITERAL_STRING("PerceivedType"),
+                                   perceivedType);
+      if (NS_SUCCEEDED(rv)) {
+        nsAutoString openWithListPath(NS_LITERAL_STRING("SystemFileAssociations\\"));
+        openWithListPath.Append(perceivedType); // no period
+        openWithListPath.AppendLiteral("\\OpenWithList");
+
+        nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                                   openWithListPath,
+                                   nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+        if (NS_SUCCEEDED(rv)) {
+          uint32_t count = 0;
+          if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
+            for (uint32_t index = 0; index < count; index++) {
+              nsAutoString appName;
+              if (NS_FAILED(regKey->GetValueName(index, appName)))
+                continue;
+              
+              // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
+              nsAutoString appFilesystemCommand;
+              if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand, 
+                                             false) ||
+                  IsPathInList(appFilesystemCommand, trackList))
+                continue;
+              ProcessPath(appList, trackList, appFilesystemCommand);
+            }
+          }
+        }
+      }
+    }
+  } // extKnown == false
+
+
+  // 7) list global HKEY_CLASSES_ROOT\*\OpenWithList
+  // Listing general purpose handlers, not specific to a mime type or file extension
+
+  workingRegistryPath = NS_LITERAL_STRING("*\\OpenWithList");
+
+  rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                    workingRegistryPath,
+                    nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_SUCCEEDED(rv)) {
+    uint32_t count = 0;
+    if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
+      for (uint32_t index = 0; index < count; index++) {
+        nsAutoString appName;
+        if (NS_FAILED(regKey->GetValueName(index, appName)))
+          continue;
+
+        // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
+        nsAutoString appFilesystemCommand;
+        if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand,
+                                       false) ||
+            IsPathInList(appFilesystemCommand, trackList))
+          continue;
+        ProcessPath(appList, trackList, appFilesystemCommand);
+      }
+    }
+    regKey->Close();
+  }
+
+
+  // 8) General application's list - not file extension specific on windows
+  workingRegistryPath = NS_LITERAL_STRING("Applications");
+
+  rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                    workingRegistryPath,
+                    nsIWindowsRegKey::ACCESS_ENUMERATE_SUB_KEYS|
+                    nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_SUCCEEDED(rv)) {
+    uint32_t count = 0;
+    if (NS_SUCCEEDED(regKey->GetChildCount(&count)) && count > 0) {
+      for (uint32_t index = 0; index < count; index++) {
+        nsAutoString appName;
+        if (NS_FAILED(regKey->GetChildName(index, appName)))
+          continue;
+
+        // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
+        nsAutoString appFilesystemCommand;
+        if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand,
+                                       false) ||
+            IsPathInList(appFilesystemCommand, trackList))
+          continue;
+        ProcessPath(appList, trackList, appFilesystemCommand);
+      }
+    }
+  }
+
+  // Return to the caller
+  *_retval = appList;
+  NS_ADDREF(*_retval);
+
+  return NS_OK;
+}
diff --git a/uriloader/exthandler/win/nsMIMEInfoWin.h b/uriloader/exthandler/win/nsMIMEInfoWin.h
new file mode 100644
index 000000000..0a5b678e8
--- /dev/null
+++ b/uriloader/exthandler/win/nsMIMEInfoWin.h
@@ -0,0 +1,71 @@
+/* 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 nsMIMEInfoWin_h_
+#define nsMIMEInfoWin_h_
+
+#include "nsMIMEInfoImpl.h"
+#include "nsIPropertyBag.h"
+#include "nsIMutableArray.h"
+#include "nsTArray.h"
+
+class nsMIMEInfoWin : public nsMIMEInfoBase, public nsIPropertyBag {
+    virtual ~nsMIMEInfoWin();
+
+  public:
+    nsMIMEInfoWin(const char* aType = "") : nsMIMEInfoBase(aType) {}
+    nsMIMEInfoWin(const nsACString& aMIMEType) : nsMIMEInfoBase(aMIMEType) {}
+    nsMIMEInfoWin(const nsACString& aType, HandlerClass aClass) :
+      nsMIMEInfoBase(aType, aClass) {}
+
+    NS_IMETHOD LaunchWithFile(nsIFile* aFile);
+    NS_IMETHOD GetHasDefaultHandler(bool * _retval);
+    NS_IMETHOD GetPossibleLocalHandlers(nsIArray **_retval); 
+
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_DECL_NSIPROPERTYBAG
+
+    void SetDefaultApplicationHandler(nsIFile* aDefaultApplication) 
+    { 
+      mDefaultApplication = aDefaultApplication; 
+    }
+
+  protected:
+    virtual nsresult LoadUriInternal(nsIURI *aURI);
+    virtual nsresult LaunchDefaultWithFile(nsIFile* aFile);
+
+  private:
+    nsCOMPtr<nsIFile>      mDefaultApplication;
+    
+    // Given a path to a local handler, return its 
+    // nsILocalHandlerApp instance.
+    bool GetLocalHandlerApp(const nsAString& aCommandHandler,
+                              nsCOMPtr<nsILocalHandlerApp>& aApp);
+
+    // Return the cleaned up file path associated 
+    // with a command verb located in root/Applications.
+    bool GetAppsVerbCommandHandler(const nsAString& appExeName,
+                                     nsAString& applicationPath,
+                                     bool bEdit);
+
+    // Return the cleaned up file path associated 
+    // with a progid command verb located in root.
+    bool GetProgIDVerbCommandHandler(const nsAString& appProgIDName,
+                                       nsAString& applicationPath,
+                                       bool bEdit);
+
+    // Lookup a rundll command handler and return
+    // a populated command template for use with rundll32.exe.
+    bool GetDllLaunchInfo(nsIFile * aDll,
+                            nsIFile * aFile,
+                            nsAString& args, bool bEdit);
+
+    // Helper routine used in tracking app lists
+    void ProcessPath(nsCOMPtr<nsIMutableArray>& appList,
+                     nsTArray<nsString>& trackList,
+                     const nsAString& appFilesystemCommand);
+
+};
+
+#endif
diff --git a/uriloader/exthandler/win/nsOSHelperAppService.cpp b/uriloader/exthandler/win/nsOSHelperAppService.cpp
new file mode 100644
index 000000000..f01f3b49b
--- /dev/null
+++ b/uriloader/exthandler/win/nsOSHelperAppService.cpp
@@ -0,0 +1,626 @@
+/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim:set ts=2 sts=2 sw=2 et cin:
+ *
+ * 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 "nsOSHelperAppService.h"
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsXPIDLString.h"
+#include "nsIURL.h"
+#include "nsIMIMEInfo.h"
+#include "nsMIMEInfoWin.h"
+#include "nsMimeTypes.h"
+#include "nsIProcess.h"
+#include "plstr.h"
+#include "nsAutoPtr.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsLocalFile.h"
+#include "nsIWindowsRegKey.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/WindowsVersion.h"
+
+// shellapi.h is needed to build with WIN32_LEAN_AND_MEAN
+#include <shellapi.h>
+#include <shlwapi.h>
+
+#define LOG(args) MOZ_LOG(mLog, mozilla::LogLevel::Debug, args)
+
+// helper methods: forward declarations...
+static nsresult GetExtensionFrom4xRegistryInfo(const nsACString& aMimeType, 
+                                               nsString& aFileExtension);
+static nsresult GetExtensionFromWindowsMimeDatabase(const nsACString& aMimeType,
+                                                    nsString& aFileExtension);
+
+nsOSHelperAppService::nsOSHelperAppService() : 
+  nsExternalHelperAppService()
+  , mAppAssoc(nullptr)
+{
+  CoInitialize(nullptr);
+  CoCreateInstance(CLSID_ApplicationAssociationRegistration, nullptr,
+                   CLSCTX_INPROC, IID_IApplicationAssociationRegistration,
+                   (void**)&mAppAssoc);
+}
+
+nsOSHelperAppService::~nsOSHelperAppService()
+{
+  if (mAppAssoc)
+    mAppAssoc->Release();
+  mAppAssoc = nullptr;
+  CoUninitialize();
+}
+
+// The windows registry provides a mime database key which lists a set of mime types and corresponding "Extension" values. 
+// we can use this to look up our mime type to see if there is a preferred extension for the mime type.
+static nsresult GetExtensionFromWindowsMimeDatabase(const nsACString& aMimeType,
+                                                    nsString& aFileExtension)
+{
+  nsAutoString mimeDatabaseKey;
+  mimeDatabaseKey.AssignLiteral("MIME\\Database\\Content Type\\");
+
+  AppendASCIItoUTF16(aMimeType, mimeDatabaseKey);
+
+  nsCOMPtr<nsIWindowsRegKey> regKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!regKey) 
+    return NS_ERROR_NOT_AVAILABLE;
+
+  nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             mimeDatabaseKey,
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  
+  if (NS_SUCCEEDED(rv))
+     regKey->ReadStringValue(NS_LITERAL_STRING("Extension"), aFileExtension);
+
+  return NS_OK;
+}
+
+// We have a serious problem!! I have this content type and the windows registry only gives me
+// helper apps based on extension. Right now, we really don't have a good place to go for 
+// trying to figure out the extension for a particular mime type....One short term hack is to look
+// this information in 4.x (it's stored in the windows regsitry). 
+static nsresult GetExtensionFrom4xRegistryInfo(const nsACString& aMimeType,
+                                               nsString& aFileExtension)
+{
+  nsCOMPtr<nsIWindowsRegKey> regKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!regKey) 
+    return NS_ERROR_NOT_AVAILABLE;
+
+  nsresult rv = regKey->
+    Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
+         NS_LITERAL_STRING("Software\\Netscape\\Netscape Navigator\\Suffixes"),
+         nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+    return NS_ERROR_NOT_AVAILABLE;
+   
+  rv = regKey->ReadStringValue(NS_ConvertASCIItoUTF16(aMimeType),
+                               aFileExtension);
+  if (NS_FAILED(rv))
+    return NS_OK;
+
+  aFileExtension.Insert(char16_t('.'), 0);
+      
+  // this may be a comma separated list of extensions...just take the 
+  // first one for now...
+
+  int32_t pos = aFileExtension.FindChar(char16_t(','));
+  if (pos > 0) {
+    // we have a comma separated list of types...
+    // truncate everything after the first comma (including the comma)
+    aFileExtension.Truncate(pos); 
+  }
+   
+  return NS_OK;
+}
+
+nsresult nsOSHelperAppService::OSProtocolHandlerExists(const char * aProtocolScheme, bool * aHandlerExists)
+{
+  // look up the protocol scheme in the windows registry....if we find a match then we have a handler for it...
+  *aHandlerExists = false;
+  if (aProtocolScheme && *aProtocolScheme)
+  {
+    // Vista: use new application association interface
+    if (mAppAssoc) {
+      wchar_t * pResult = nullptr;
+      NS_ConvertASCIItoUTF16 scheme(aProtocolScheme);
+      // We are responsible for freeing returned strings.
+      HRESULT hr = mAppAssoc->QueryCurrentDefault(scheme.get(),
+                                                  AT_URLPROTOCOL, AL_EFFECTIVE,
+                                                  &pResult);
+      if (SUCCEEDED(hr)) {
+        CoTaskMemFree(pResult);
+        *aHandlerExists = true;
+      }
+      return NS_OK;
+    }
+
+    HKEY hKey;
+    LONG err = ::RegOpenKeyExW(HKEY_CLASSES_ROOT,
+                               NS_ConvertASCIItoUTF16(aProtocolScheme).get(),
+                               0,
+                               KEY_QUERY_VALUE,
+                               &hKey);
+    if (err == ERROR_SUCCESS)
+    {
+      err = ::RegQueryValueExW(hKey, L"URL Protocol",
+                               nullptr, nullptr, nullptr, nullptr);
+      *aHandlerExists = (err == ERROR_SUCCESS);
+      // close the key
+      ::RegCloseKey(hKey);
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsOSHelperAppService::GetApplicationDescription(const nsACString& aScheme, nsAString& _retval)
+{
+  nsCOMPtr<nsIWindowsRegKey> regKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!regKey) 
+    return NS_ERROR_NOT_AVAILABLE;
+
+  NS_ConvertASCIItoUTF16 buf(aScheme);
+
+  if (mozilla::IsWin8OrLater()) {
+    wchar_t result[1024];
+    DWORD resultSize = 1024;
+    HRESULT hr = AssocQueryString(0x1000 /* ASSOCF_IS_PROTOCOL */,
+                                  ASSOCSTR_FRIENDLYAPPNAME,
+                                  buf.get(),
+                                  NULL,
+                                  result,
+                                  &resultSize);
+    if (SUCCEEDED(hr)) {
+      _retval = result;
+      return NS_OK;
+    }
+  }
+
+  if (mAppAssoc) {
+    // Vista: use new application association interface
+    wchar_t * pResult = nullptr;
+    // We are responsible for freeing returned strings.
+    HRESULT hr = mAppAssoc->QueryCurrentDefault(buf.get(),
+                                                AT_URLPROTOCOL, AL_EFFECTIVE,
+                                                &pResult);
+    if (SUCCEEDED(hr)) {
+      nsCOMPtr<nsIFile> app;
+      nsAutoString appInfo(pResult);
+      CoTaskMemFree(pResult);
+      if (NS_SUCCEEDED(GetDefaultAppInfo(appInfo, _retval, getter_AddRefs(app))))
+        return NS_OK;
+    }
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCOMPtr<nsIFile> app;
+  GetDefaultAppInfo(buf, _retval, getter_AddRefs(app));
+
+  if (!_retval.Equals(buf))
+    return NS_OK;
+
+  // Fall back to full path
+  buf.AppendLiteral("\\shell\\open\\command");
+  nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             buf,
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+    return NS_ERROR_NOT_AVAILABLE;   
+   
+  rv = regKey->ReadStringValue(EmptyString(), _retval); 
+
+  return NS_SUCCEEDED(rv) ? NS_OK : NS_ERROR_NOT_AVAILABLE;
+}
+
+// GetMIMEInfoFromRegistry: This function obtains the values of some of the nsIMIMEInfo
+// attributes for the mimeType/extension associated with the input registry key.  The default
+// entry for that key is the name of a registry key under HKEY_CLASSES_ROOT.  The default
+// value for *that* key is the descriptive name of the type.  The EditFlags value is a binary
+// value; the low order bit of the third byte of which indicates that the user does not need
+// to be prompted.
+//
+// This function sets only the Description attribute of the input nsIMIMEInfo.
+/* static */
+nsresult nsOSHelperAppService::GetMIMEInfoFromRegistry(const nsAFlatString& fileType, nsIMIMEInfo *pInfo)
+{
+  nsresult rv = NS_OK;
+
+  NS_ENSURE_ARG(pInfo);
+  nsCOMPtr<nsIWindowsRegKey> regKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!regKey) 
+    return NS_ERROR_NOT_AVAILABLE;
+
+  rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                    fileType, nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+    return NS_ERROR_FAILURE;
+ 
+  // OK, the default value here is the description of the type.
+  nsAutoString description;
+  rv = regKey->ReadStringValue(EmptyString(), description);
+  if (NS_SUCCEEDED(rv))
+    pInfo->SetDescription(description);
+
+  return NS_OK;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// method overrides used to gather information from the windows registry for
+// various mime types. 
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Looks up the type for the extension aExt and compares it to aType
+/* static */ bool
+nsOSHelperAppService::typeFromExtEquals(const char16_t* aExt, const char *aType)
+{
+  if (!aType)
+    return false;
+  nsAutoString fileExtToUse;
+  if (aExt[0] != char16_t('.'))
+    fileExtToUse = char16_t('.');
+
+  fileExtToUse.Append(aExt);
+
+  bool eq = false;
+  nsCOMPtr<nsIWindowsRegKey> regKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!regKey) 
+    return eq;
+
+  nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             fileExtToUse,
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+      return eq;
+   
+  nsAutoString type;
+  rv = regKey->ReadStringValue(NS_LITERAL_STRING("Content Type"), type);
+  if (NS_SUCCEEDED(rv))
+     eq = type.EqualsASCII(aType);
+
+  return eq;
+}
+
+// The "real" name of a given helper app (as specified by the path to the 
+// executable file held in various registry keys) is stored n the VERSIONINFO
+// block in the file's resources. We need to find the path to the executable
+// and then retrieve the "FileDescription" field value from the file. 
+nsresult
+nsOSHelperAppService::GetDefaultAppInfo(const nsAString& aAppInfo,
+                                        nsAString& aDefaultDescription, 
+                                        nsIFile** aDefaultApplication)
+{
+  nsAutoString handlerCommand;
+
+  // If all else fails, use the file type key name, which will be 
+  // something like "pngfile" for .pngs, "WMVFile" for .wmvs, etc. 
+  aDefaultDescription = aAppInfo;
+  *aDefaultApplication = nullptr;
+
+  if (aAppInfo.IsEmpty())
+    return NS_ERROR_FAILURE;
+
+  // aAppInfo may be a file, file path, program id, or
+  // Applications reference -
+  // c:\dir\app.exe
+  // Applications\appfile.exe/dll (shell\open...)
+  // ProgID.progid (shell\open...)
+
+  nsAutoString handlerKeyName(aAppInfo);
+
+  nsCOMPtr<nsIWindowsRegKey> chkKey = 
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!chkKey) 
+    return NS_ERROR_FAILURE;
+      
+  nsresult rv = chkKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             handlerKeyName, 
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv)) {
+    // It's a file system path to a handler 
+    handlerCommand.Assign(aAppInfo);
+  }
+  else {
+    handlerKeyName.AppendLiteral("\\shell\\open\\command");
+    nsCOMPtr<nsIWindowsRegKey> regKey = 
+      do_CreateInstance("@mozilla.org/windows-registry-key;1");
+    if (!regKey) 
+      return NS_ERROR_FAILURE;
+
+    nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                               handlerKeyName, 
+                               nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_FAILED(rv))
+      return NS_ERROR_FAILURE;
+     
+    // OK, the default value here is the description of the type.
+    rv = regKey->ReadStringValue(EmptyString(), handlerCommand);
+    if (NS_FAILED(rv)) {
+
+      // Check if there is a DelegateExecute string
+      nsAutoString delegateExecute;
+      rv = regKey->ReadStringValue(NS_LITERAL_STRING("DelegateExecute"), delegateExecute);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Look for InProcServer32
+      nsAutoString delegateExecuteRegPath;
+      delegateExecuteRegPath.AssignLiteral("CLSID\\");
+      delegateExecuteRegPath.Append(delegateExecute);
+      delegateExecuteRegPath.AppendLiteral("\\InProcServer32");
+      rv = chkKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                        delegateExecuteRegPath, 
+                        nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+      if (NS_SUCCEEDED(rv)) {
+        rv = chkKey->ReadStringValue(EmptyString(), handlerCommand);
+      }
+
+      if (NS_FAILED(rv)) {
+        // Look for LocalServer32
+        delegateExecuteRegPath.AssignLiteral("CLSID\\");
+        delegateExecuteRegPath.Append(delegateExecute);
+        delegateExecuteRegPath.AppendLiteral("\\LocalServer32");
+        rv = chkKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                          delegateExecuteRegPath, 
+                          nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = chkKey->ReadStringValue(EmptyString(), handlerCommand);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+
+  // XXX FIXME: If this fails, the UI will display the full command
+  // string.
+  // There are some rare cases this can happen - ["url.dll" -foo]
+  // for example won't resolve correctly to the system dir. The 
+  // subsequent launch of the helper app will work though.
+  nsCOMPtr<nsILocalFileWin> lf = new nsLocalFile();
+  rv = lf->InitWithCommandLine(handlerCommand);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // The "FileDescription" field contains the actual name of the application.
+  lf->GetVersionInfoField("FileDescription", aDefaultDescription);
+  lf.forget(aDefaultApplication);
+
+  return NS_OK;
+}
+
+already_AddRefed<nsMIMEInfoWin> nsOSHelperAppService::GetByExtension(const nsAFlatString& aFileExt, const char *aTypeHint)
+{
+  if (aFileExt.IsEmpty())
+    return nullptr;
+
+  // Determine the mime type.
+  nsAutoCString typeToUse;
+  if (aTypeHint && *aTypeHint) {
+    typeToUse.Assign(aTypeHint);
+  } else if (!GetMIMETypeFromOSForExtension(NS_ConvertUTF16toUTF8(aFileExt), typeToUse)) {
+    return nullptr;
+  }
+
+  RefPtr<nsMIMEInfoWin> mimeInfo = new nsMIMEInfoWin(typeToUse);
+
+  // windows registry assumes your file extension is going to include the '.',
+  // but our APIs expect it to not be there, so make sure we normalize that bit.
+  nsAutoString fileExtToUse;
+  if (aFileExt.First() != char16_t('.'))
+    fileExtToUse = char16_t('.');
+
+  fileExtToUse.Append(aFileExt);
+
+  // don't append the '.' for our APIs.
+  mimeInfo->AppendExtension(NS_ConvertUTF16toUTF8(Substring(fileExtToUse, 1)));
+  mimeInfo->SetPreferredAction(nsIMIMEInfo::useSystemDefault);
+
+  nsAutoString appInfo;
+  bool found;
+
+  // Retrieve the default application for this extension
+  if (mAppAssoc) {
+    // Vista: use the new application association COM interfaces
+    // for resolving helpers.
+    nsString assocType(fileExtToUse);
+    wchar_t * pResult = nullptr;
+    HRESULT hr = mAppAssoc->QueryCurrentDefault(assocType.get(),
+                                                AT_FILEEXTENSION, AL_EFFECTIVE,
+                                                &pResult);
+    if (SUCCEEDED(hr)) {
+      found = true;
+      appInfo.Assign(pResult);
+      CoTaskMemFree(pResult);
+    } 
+    else {
+      found = false;
+    }
+  } 
+  else
+  {
+    nsCOMPtr<nsIWindowsRegKey> regKey =
+      do_CreateInstance("@mozilla.org/windows-registry-key;1");
+    if (!regKey)
+      return nullptr;
+    nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                               fileExtToUse,
+                               nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+    if (NS_SUCCEEDED(rv)) {
+      found = NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(),
+                                                   appInfo));
+    }
+  }
+
+  // Bug 358297 - ignore the default handler, force the user to choose app
+  if (appInfo.EqualsLiteral("XPSViewer.Document"))
+    found = false;
+
+  if (!found) {
+    return nullptr;
+  }
+
+  // Get other nsIMIMEInfo fields from registry, if possible.
+  nsAutoString defaultDescription;
+  nsCOMPtr<nsIFile> defaultApplication;
+  
+  if (NS_FAILED(GetDefaultAppInfo(appInfo, defaultDescription,
+                                  getter_AddRefs(defaultApplication)))) {
+    return nullptr;
+  }
+
+  mimeInfo->SetDefaultDescription(defaultDescription);
+  mimeInfo->SetDefaultApplicationHandler(defaultApplication);
+
+  // Grab the general description
+  GetMIMEInfoFromRegistry(appInfo, mimeInfo);
+
+  return mimeInfo.forget();
+}
+
+already_AddRefed<nsIMIMEInfo> nsOSHelperAppService::GetMIMEInfoFromOS(const nsACString& aMIMEType, const nsACString& aFileExt, bool *aFound)
+{
+  *aFound = true;
+
+  const nsCString& flatType = PromiseFlatCString(aMIMEType);
+  const nsCString& flatExt = PromiseFlatCString(aFileExt);
+
+  nsAutoString fileExtension;
+  /* XXX The Equals is a gross hack to wallpaper over the most common Win32
+   * extension issues caused by the fix for bug 116938.  See bug
+   * 120327, comment 271 for why this is needed.  Not even sure we
+   * want to remove this once we have fixed all this stuff to work
+   * right; any info we get from the OS on this type is pretty much
+   * useless....
+   * We'll do extension-based lookup for this type later in this function.
+   */
+  if (!aMIMEType.LowerCaseEqualsLiteral(APPLICATION_OCTET_STREAM)) {
+    // (1) try to use the windows mime database to see if there is a mapping to a file extension
+    // (2) try to see if we have some left over 4.x registry info we can peek at...
+    GetExtensionFromWindowsMimeDatabase(aMIMEType, fileExtension);
+    LOG(("Windows mime database: extension '%s'\n", fileExtension.get()));
+    if (fileExtension.IsEmpty()) {
+      GetExtensionFrom4xRegistryInfo(aMIMEType, fileExtension);
+      LOG(("4.x Registry: extension '%s'\n", fileExtension.get()));
+    }
+  }
+  // If we found an extension for the type, do the lookup
+  RefPtr<nsMIMEInfoWin> mi;
+  if (!fileExtension.IsEmpty())
+    mi = GetByExtension(fileExtension, flatType.get());
+  LOG(("Extension lookup on '%s' found: 0x%p\n", fileExtension.get(), mi.get()));
+
+  bool hasDefault = false;
+  if (mi) {
+    mi->GetHasDefaultHandler(&hasDefault);
+    // OK. We might have the case that |aFileExt| is a valid extension for the
+    // mimetype we were given. In that case, we do want to append aFileExt
+    // to the mimeinfo that we have. (E.g.: We are asked for video/mpeg and
+    // .mpg, but the primary extension for video/mpeg is .mpeg. But because
+    // .mpg is an extension for video/mpeg content, we want to append it)
+    if (!aFileExt.IsEmpty() && typeFromExtEquals(NS_ConvertUTF8toUTF16(flatExt).get(), flatType.get())) {
+      LOG(("Appending extension '%s' to mimeinfo, because its mimetype is '%s'\n",
+           flatExt.get(), flatType.get()));
+      bool extExist = false;
+      mi->ExtensionExists(aFileExt, &extExist);
+      if (!extExist)
+        mi->AppendExtension(aFileExt);
+    }
+  }
+  if (!mi || !hasDefault) {
+    RefPtr<nsMIMEInfoWin> miByExt =
+      GetByExtension(NS_ConvertUTF8toUTF16(aFileExt), flatType.get());
+    LOG(("Ext. lookup for '%s' found 0x%p\n", flatExt.get(), miByExt.get()));
+    if (!miByExt && mi)
+      return mi.forget();
+    if (miByExt && !mi) {
+      return miByExt.forget();
+    }
+    if (!miByExt && !mi) {
+      *aFound = false;
+      mi = new nsMIMEInfoWin(flatType);
+      if (!aFileExt.IsEmpty()) {
+        mi->AppendExtension(aFileExt);
+      }
+      
+      return mi.forget();
+    }
+
+    // if we get here, mi has no default app. copy from extension lookup.
+    nsCOMPtr<nsIFile> defaultApp;
+    nsAutoString desc;
+    miByExt->GetDefaultDescription(desc);
+
+    mi->SetDefaultDescription(desc);
+  }
+  return mi.forget();
+}
+
+NS_IMETHODIMP
+nsOSHelperAppService::GetProtocolHandlerInfoFromOS(const nsACString &aScheme,
+                                                   bool *found,
+                                                   nsIHandlerInfo **_retval)
+{
+  NS_ASSERTION(!aScheme.IsEmpty(), "No scheme was specified!");
+
+  nsresult rv = OSProtocolHandlerExists(nsPromiseFlatCString(aScheme).get(),
+                                        found);
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsMIMEInfoWin *handlerInfo =
+    new nsMIMEInfoWin(aScheme, nsMIMEInfoBase::eProtocolInfo);
+  NS_ENSURE_TRUE(handlerInfo, NS_ERROR_OUT_OF_MEMORY);
+  NS_ADDREF(*_retval = handlerInfo);
+
+  if (!*found) {
+    // Code that calls this requires an object regardless if the OS has
+    // something for us, so we return the empty object.
+    return NS_OK;
+  }
+
+  nsAutoString desc;
+  GetApplicationDescription(aScheme, desc);
+  handlerInfo->SetDefaultDescription(desc);
+
+  return NS_OK;
+}
+
+bool
+nsOSHelperAppService::GetMIMETypeFromOSForExtension(const nsACString& aExtension,
+                                                    nsACString& aMIMEType)
+{
+  if (aExtension.IsEmpty())
+    return false;
+
+  // windows registry assumes your file extension is going to include the '.'.
+  // so make sure it's there...
+  nsAutoString fileExtToUse;
+  if (aExtension.First() != '.')
+    fileExtToUse = char16_t('.');
+
+  AppendUTF8toUTF16(aExtension, fileExtToUse);
+
+  // Try to get an entry from the windows registry.
+  nsCOMPtr<nsIWindowsRegKey> regKey =
+    do_CreateInstance("@mozilla.org/windows-registry-key;1");
+  if (!regKey)
+    return false;
+
+  nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
+                             fileExtToUse,
+                             nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+  if (NS_FAILED(rv))
+    return false;
+
+  nsAutoString mimeType;
+  if (NS_FAILED(regKey->ReadStringValue(NS_LITERAL_STRING("Content Type"),
+                mimeType)) || mimeType.IsEmpty()) {
+    return false;
+  }
+  // Content-Type is always in ASCII
+  aMIMEType.Truncate();
+  LossyAppendUTF16toASCII(mimeType, aMIMEType);
+  return true;
+}
diff --git a/uriloader/exthandler/win/nsOSHelperAppService.h b/uriloader/exthandler/win/nsOSHelperAppService.h
new file mode 100644
index 000000000..b00529433
--- /dev/null
+++ b/uriloader/exthandler/win/nsOSHelperAppService.h
@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 3; 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 nsOSHelperAppService_h__
+#define nsOSHelperAppService_h__
+
+// The OS helper app service is a subclass of nsExternalHelperAppService and is implemented on each
+// platform. It contains platform specific code for finding helper applications for a given mime type
+// in addition to launching those applications.
+
+#include "nsExternalHelperAppService.h"
+#include "nsCExternalHandlerService.h"
+#include "nsMIMEInfoImpl.h"
+#include "nsCOMPtr.h"
+#include <windows.h>
+
+#ifdef _WIN32_WINNT
+#undef _WIN32_WINNT
+#endif
+#define _WIN32_WINNT 0x0600
+#include <shlobj.h>
+
+class nsMIMEInfoWin;
+
+class nsOSHelperAppService : public nsExternalHelperAppService
+{
+public:
+  nsOSHelperAppService();
+  virtual ~nsOSHelperAppService();
+
+  // override nsIExternalProtocolService methods
+  nsresult OSProtocolHandlerExists(const char * aProtocolScheme, bool * aHandlerExists);
+  nsresult LoadUriInternal(nsIURI * aURL);
+  NS_IMETHOD GetApplicationDescription(const nsACString& aScheme, nsAString& _retval);
+
+  // method overrides for windows registry look up steps....
+  already_AddRefed<nsIMIMEInfo> GetMIMEInfoFromOS(const nsACString& aMIMEType, const nsACString& aFileExt, bool *aFound);
+  NS_IMETHOD GetProtocolHandlerInfoFromOS(const nsACString &aScheme, 
+                                          bool *found,
+                                          nsIHandlerInfo **_retval);
+  virtual bool GetMIMETypeFromOSForExtension(const nsACString& aExtension,
+                                             nsACString& aMIMEType) override;
+
+  /** Get the string value of a registry value and store it in result.
+   * @return true on success, false on failure
+   */
+  static bool GetValueString(HKEY hKey, const char16_t* pValueName, nsAString& result);
+
+protected:
+  nsresult GetDefaultAppInfo(const nsAString& aTypeName, nsAString& aDefaultDescription, nsIFile** aDefaultApplication);
+  // Lookup a mime info by extension, using an optional type hint
+  already_AddRefed<nsMIMEInfoWin> GetByExtension(const nsAFlatString& aFileExt, const char *aTypeHint = nullptr);
+  nsresult FindOSMimeInfoForType(const char * aMimeContentType, nsIURI * aURI, char ** aFileExtension, nsIMIMEInfo ** aMIMEInfo);
+
+  static nsresult GetMIMEInfoFromRegistry(const nsAFlatString& fileType, nsIMIMEInfo *pInfo);
+  /// Looks up the type for the extension aExt and compares it to aType
+  static bool typeFromExtEquals(const char16_t* aExt, const char *aType);
+
+private:
+  IApplicationAssociationRegistration* mAppAssoc;
+};
+
+#endif // nsOSHelperAppService_h__