Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

8 files changed, 1362 insertions, 0 deletions

diff --git a/uriloader/exthandler/mac/nsDecodeAppleFile.cpp b/uriloader/exthandler/mac/nsDecodeAppleFile.cpp
new file mode 100644
index 0000000000..69f13ab8c8
--- /dev/null
+++ b/uriloader/exthandler/mac/nsDecodeAppleFile.cpp
@@ -0,0 +1,361 @@
+/* -*- Mode: C++; tab-width: 4; 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 "nsDecodeAppleFile.h"
+#include "nsCRT.h"
+
+NS_IMPL_ADDREF(nsDecodeAppleFile)
+NS_IMPL_RELEASE(nsDecodeAppleFile)
+
+NS_INTERFACE_MAP_BEGIN(nsDecodeAppleFile)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIOutputStream)
+  NS_INTERFACE_MAP_ENTRY(nsIOutputStream)
+NS_INTERFACE_MAP_END
+
+nsDecodeAppleFile::nsDecodeAppleFile() {
+  m_state = parseHeaders;
+  m_dataBufferLength = 0;
+  m_dataBuffer = (unsigned char*)malloc(MAX_BUFFERSIZE);
+  m_entries = nullptr;
+  m_rfRefNum = -1;
+  m_totalDataForkWritten = 0;
+  m_totalResourceForkWritten = 0;
+  m_headerOk = false;
+
+  m_comment[0] = 0;
+  memset(&m_dates, 0, sizeof(m_dates));
+  memset(&m_finderInfo, 0, sizeof(m_dates));
+  memset(&m_finderExtraInfo, 0, sizeof(m_dates));
+}
+
+nsDecodeAppleFile::~nsDecodeAppleFile() {
+  free(m_dataBuffer);
+  m_dataBuffer = nullptr;
+  if (m_entries) delete[] m_entries;
+}
+
+NS_IMETHODIMP nsDecodeAppleFile::Initialize(nsIOutputStream* output,
+                                            nsIFile* file) {
+  m_output = output;
+
+  nsCOMPtr<nsILocalFileMac> macFile = do_QueryInterface(file);
+  macFile->GetTargetFSSpec(&m_fsFileSpec);
+
+  m_offset = 0;
+  m_dataForkOffset = 0;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDecodeAppleFile::Close(void) {
+  nsresult rv;
+  rv = m_output->Close();
+
+  int32_t i;
+
+  if (m_rfRefNum != -1) FSClose(m_rfRefNum);
+
+  /* Check if the file is complete and if it's the case, write file attributes
+   */
+  if (m_headerOk) {
+    bool dataOk = true; /* It's ok if the file doesn't have a datafork,
+                           therefore set it to true by default. */
+    if (m_headers.magic == APPLESINGLE_MAGIC) {
+      for (i = 0; i < m_headers.entriesCount; i++)
+        if (ENT_DFORK == m_entries[i].id) {
+          dataOk = (bool)(m_totalDataForkWritten == m_entries[i].length);
+          break;
+        }
+    }
+
+    bool resourceOk = FALSE;
+    for (i = 0; i < m_headers.entriesCount; i++)
+      if (ENT_RFORK == m_entries[i].id) {
+        resourceOk = (bool)(m_totalResourceForkWritten == m_entries[i].length);
+        break;
+      }
+
+    if (dataOk && resourceOk) {
+      HFileInfo* fpb;
+      CInfoPBRec cipbr;
+
+      fpb = (HFileInfo*)&cipbr;
+      fpb->ioVRefNum = m_fsFileSpec.vRefNum;
+      fpb->ioDirID = m_fsFileSpec.parID;
+      fpb->ioNamePtr = m_fsFileSpec.name;
+      fpb->ioFDirIndex = 0;
+      PBGetCatInfoSync(&cipbr);
+
+      /* set finder info */
+      memcpy(&fpb->ioFlFndrInfo, &m_finderInfo, sizeof(FInfo));
+      memcpy(&fpb->ioFlXFndrInfo, &m_finderExtraInfo, sizeof(FXInfo));
+      fpb->ioFlFndrInfo.fdFlags &=
+          0xfc00; /* clear flags maintained by finder */
+
+      /* set file dates */
+      fpb->ioFlCrDat = m_dates.create - CONVERT_TIME;
+      fpb->ioFlMdDat = m_dates.modify - CONVERT_TIME;
+      fpb->ioFlBkDat = m_dates.backup - CONVERT_TIME;
+
+      /* update file info */
+      fpb->ioDirID = fpb->ioFlParID;
+      PBSetCatInfoSync(&cipbr);
+
+      /* set comment */
+      IOParam vinfo;
+      GetVolParmsInfoBuffer vp;
+      DTPBRec dtp;
+
+      memset((void*)&vinfo, 0, sizeof(vinfo));
+      vinfo.ioVRefNum = fpb->ioVRefNum;
+      vinfo.ioBuffer = (Ptr)&vp;
+      vinfo.ioReqCount = sizeof(vp);
+      if (PBHGetVolParmsSync((HParmBlkPtr)&vinfo) == noErr &&
+          ((vp.vMAttrib >> bHasDesktopMgr) & 1)) {
+        memset((void*)&dtp, 0, sizeof(dtp));
+        dtp.ioVRefNum = fpb->ioVRefNum;
+        if (PBDTGetPath(&dtp) == noErr) {
+          dtp.ioDTBuffer = (Ptr)&m_comment[1];
+          dtp.ioNamePtr = fpb->ioNamePtr;
+          dtp.ioDirID = fpb->ioDirID;
+          dtp.ioDTReqCount = m_comment[0];
+          if (PBDTSetCommentSync(&dtp) == noErr) PBDTFlushSync(&dtp);
+        }
+      }
+    }
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsDecodeAppleFile::Flush(void) { return m_output->Flush(); }
+
+NS_IMETHODIMP nsDecodeAppleFile::StreamStatus(void) {
+  return m_output->StreamStatus();
+}
+
+NS_IMETHODIMP nsDecodeAppleFile::WriteFrom(nsIInputStream* inStr,
+                                           uint32_t count, uint32_t* _retval) {
+  return m_output->WriteFrom(inStr, count, _retval);
+}
+
+NS_IMETHODIMP nsDecodeAppleFile::WriteSegments(nsReadSegmentFun reader,
+                                               void* closure, uint32_t count,
+                                               uint32_t* _retval) {
+  return m_output->WriteSegments(reader, closure, count, _retval);
+}
+
+NS_IMETHODIMP nsDecodeAppleFile::IsNonBlocking(bool* aNonBlocking) {
+  return m_output->IsNonBlocking(aNonBlocking);
+}
+
+NS_IMETHODIMP nsDecodeAppleFile::Write(const char* buffer, uint32_t bufferSize,
+                                       uint32_t* writeCount) {
+  /* WARNING: to simplify my life, I presume that I should get all appledouble
+     headers in the first block, else I would have to implement a buffer */
+
+  const char* buffPtr = buffer;
+  uint32_t dataCount;
+  int32_t i;
+  nsresult rv = NS_OK;
+
+  *writeCount = 0;
+
+  while (bufferSize > 0 && NS_SUCCEEDED(rv)) {
+    switch (m_state) {
+      case parseHeaders:
+        dataCount = sizeof(ap_header) - m_dataBufferLength;
+        if (dataCount > bufferSize) dataCount = bufferSize;
+        memcpy(&m_dataBuffer[m_dataBufferLength], buffPtr, dataCount);
+        m_dataBufferLength += dataCount;
+
+        if (m_dataBufferLength == sizeof(ap_header)) {
+          memcpy(&m_headers, m_dataBuffer, sizeof(ap_header));
+
+          /* Check header to be sure we are dealing with the right kind of data,
+           * else just write it to the data fork. */
+          if ((m_headers.magic == APPLEDOUBLE_MAGIC ||
+               m_headers.magic == APPLESINGLE_MAGIC) &&
+              m_headers.version == VERSION && m_headers.entriesCount) {
+            /* Just to be sure, the filler must contains only 0 */
+            for (i = 0; i < 4 && m_headers.fill[i] == 0L; i++)
+              ;
+            if (i == 4) m_state = parseEntries;
+          }
+          m_dataBufferLength = 0;
+
+          if (m_state == parseHeaders) {
+            dataCount = 0;
+            m_state = parseWriteThrough;
+          }
+        }
+        break;
+
+      case parseEntries:
+        if (!m_entries) {
+          m_entries = new ap_entry[m_headers.entriesCount];
+          if (!m_entries) return NS_ERROR_OUT_OF_MEMORY;
+        }
+        uint32_t entriesSize = sizeof(ap_entry) * m_headers.entriesCount;
+        dataCount = entriesSize - m_dataBufferLength;
+        if (dataCount > bufferSize) dataCount = bufferSize;
+        memcpy(&m_dataBuffer[m_dataBufferLength], buffPtr, dataCount);
+        m_dataBufferLength += dataCount;
+
+        if (m_dataBufferLength == entriesSize) {
+          for (i = 0; i < m_headers.entriesCount; i++) {
+            memcpy(&m_entries[i], &m_dataBuffer[i * sizeof(ap_entry)],
+                   sizeof(ap_entry));
+            if (m_headers.magic == APPLEDOUBLE_MAGIC) {
+              uint32_t offset = m_entries[i].offset + m_entries[i].length;
+              if (offset > m_dataForkOffset) m_dataForkOffset = offset;
+            }
+          }
+          m_headerOk = true;
+          m_state = parseLookupPart;
+        }
+        break;
+
+      case parseLookupPart:
+        /* which part are we parsing? */
+        m_currentPartID = -1;
+        for (i = 0; i < m_headers.entriesCount; i++)
+          if (m_offset == m_entries[i].offset && m_entries[i].length) {
+            m_currentPartID = m_entries[i].id;
+            m_currentPartLength = m_entries[i].length;
+            m_currentPartCount = 0;
+
+            switch (m_currentPartID) {
+              case ENT_DFORK:
+                m_state = parseDataFork;
+                break;
+              case ENT_RFORK:
+                m_state = parseResourceFork;
+                break;
+
+              case ENT_COMMENT:
+              case ENT_DATES:
+              case ENT_FINFO:
+                m_dataBufferLength = 0;
+                m_state = parsePart;
+                break;
+
+              default:
+                m_state = parseSkipPart;
+                break;
+            }
+            break;
+          }
+
+        if (m_currentPartID == -1) {
+          /* maybe is the datafork of an appledouble file? */
+          if (m_offset == m_dataForkOffset) {
+            m_currentPartID = ENT_DFORK;
+            m_currentPartLength = -1;
+            m_currentPartCount = 0;
+            m_state = parseDataFork;
+          } else
+            dataCount = 1;
+        }
+        break;
+
+      case parsePart:
+        dataCount = m_currentPartLength - m_dataBufferLength;
+        if (dataCount > bufferSize) dataCount = bufferSize;
+        memcpy(&m_dataBuffer[m_dataBufferLength], buffPtr, dataCount);
+        m_dataBufferLength += dataCount;
+
+        if (m_dataBufferLength == m_currentPartLength) {
+          switch (m_currentPartID) {
+            case ENT_COMMENT:
+              m_comment[0] =
+                  m_currentPartLength > 255 ? 255 : m_currentPartLength;
+              memcpy(&m_comment[1], buffPtr, m_comment[0]);
+              break;
+            case ENT_DATES:
+              if (m_currentPartLength == sizeof(m_dates))
+                memcpy(&m_dates, buffPtr, m_currentPartLength);
+              break;
+            case ENT_FINFO:
+              if (m_currentPartLength ==
+                  (sizeof(m_finderInfo) + sizeof(m_finderExtraInfo))) {
+                memcpy(&m_finderInfo, buffPtr, sizeof(m_finderInfo));
+                memcpy(&m_finderExtraInfo, buffPtr + sizeof(m_finderInfo),
+                       sizeof(m_finderExtraInfo));
+              }
+              break;
+          }
+          m_state = parseLookupPart;
+        }
+        break;
+
+      case parseSkipPart:
+        dataCount = m_currentPartLength - m_currentPartCount;
+        if (dataCount > bufferSize)
+          dataCount = bufferSize;
+        else
+          m_state = parseLookupPart;
+        break;
+
+      case parseDataFork:
+        if (m_headers.magic == APPLEDOUBLE_MAGIC)
+          dataCount = bufferSize;
+        else {
+          dataCount = m_currentPartLength - m_currentPartCount;
+          if (dataCount > bufferSize)
+            dataCount = bufferSize;
+          else
+            m_state = parseLookupPart;
+        }
+
+        if (m_output) {
+          uint32_t writeCount;
+          rv = m_output->Write((const char*)buffPtr, dataCount, &writeCount);
+          if (dataCount != writeCount) rv = NS_ERROR_FAILURE;
+          m_totalDataForkWritten += dataCount;
+        }
+
+        break;
+
+      case parseResourceFork:
+        dataCount = m_currentPartLength - m_currentPartCount;
+        if (dataCount > bufferSize)
+          dataCount = bufferSize;
+        else
+          m_state = parseLookupPart;
+
+        if (m_rfRefNum == -1) {
+          if (noErr != FSpOpenRF(&m_fsFileSpec, fsWrPerm, &m_rfRefNum))
+            return NS_ERROR_FAILURE;
+        }
+
+        long count = dataCount;
+        if (noErr != FSWrite(m_rfRefNum, &count, buffPtr) || count != dataCount)
+          return NS_ERROR_FAILURE;
+        m_totalResourceForkWritten += dataCount;
+        break;
+
+      case parseWriteThrough:
+        dataCount = bufferSize;
+        if (m_output) {
+          uint32_t writeCount;
+          rv = m_output->Write((const char*)buffPtr, dataCount, &writeCount);
+          if (dataCount != writeCount) rv = NS_ERROR_FAILURE;
+        }
+        break;
+    }
+
+    if (dataCount) {
+      *writeCount += dataCount;
+      bufferSize -= dataCount;
+      buffPtr += dataCount;
+      m_currentPartCount += dataCount;
+      m_offset += dataCount;
+      dataCount = 0;
+    }
+  }
+
+  return rv;
+}
diff --git a/uriloader/exthandler/mac/nsDecodeAppleFile.h b/uriloader/exthandler/mac/nsDecodeAppleFile.h
new file mode 100644
index 0000000000..22279a8a49
--- /dev/null
+++ b/uriloader/exthandler/mac/nsDecodeAppleFile.h
@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; 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 nsDecodeAppleFile_h__
+#define nsDecodeAppleFile_h__
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsIOutputStream.h"
+
+/*
+** applefile definitions used
+*/
+#if PRAGMA_STRUCT_ALIGN
+#  pragma options align = mac68k
+#endif
+
+#define APPLESINGLE_MAGIC 0x00051600L
+#define APPLEDOUBLE_MAGIC 0x00051607L
+#define VERSION 0x00020000
+
+#define NUM_ENTRIES 6
+
+#define ENT_DFORK 1L
+#define ENT_RFORK 2L
+#define ENT_NAME 3L
+#define ENT_COMMENT 4L
+#define ENT_DATES 8L
+#define ENT_FINFO 9L
+
+#define CONVERT_TIME 1265437696L
+
+/*
+** data type used in the header decoder.
+*/
+typedef struct ap_header {
+  int32_t magic;
+  int32_t version;
+  int32_t fill[4];
+  int16_t entriesCount;
+
+} ap_header;
+
+typedef struct ap_entry {
+  int32_t id;
+  int32_t offset;
+  int32_t length;
+
+} ap_entry;
+
+typedef struct ap_dates {
+  int32_t create, modify, backup, access;
+
+} ap_dates;
+
+#if PRAGMA_STRUCT_ALIGN
+#  pragma options align = reset
+#endif
+
+/*
+**Error codes
+*/
+enum { errADNotEnoughData = -12099, errADNotSupported, errADBadVersion };
+
+class nsDecodeAppleFile : public nsIOutputStream {
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIOUTPUTSTREAM
+
+  nsDecodeAppleFile();
+  virtual ~nsDecodeAppleFile();
+
+  [[nodiscard]] nsresult Initialize(nsIOutputStream* output, nsIFile* file);
+
+ private:
+#define MAX_BUFFERSIZE 1024
+  enum ParserState {
+    parseHeaders,
+    parseEntries,
+    parseLookupPart,
+    parsePart,
+    parseSkipPart,
+    parseDataFork,
+    parseResourceFork,
+    parseWriteThrough
+  };
+
+  nsCOMPtr<nsIOutputStream> m_output;
+  FSSpec m_fsFileSpec;
+  SInt16 m_rfRefNum;
+
+  unsigned char* m_dataBuffer;
+  int32_t m_dataBufferLength;
+  ParserState m_state;
+  ap_header m_headers;
+  ap_entry* m_entries;
+  int32_t m_offset;
+  int32_t m_dataForkOffset;
+  int32_t m_totalDataForkWritten;
+  int32_t m_totalResourceForkWritten;
+  bool m_headerOk;
+
+  int32_t m_currentPartID;
+  int32_t m_currentPartLength;
+  int32_t m_currentPartCount;
+
+  Str255 m_comment;
+  ap_dates m_dates;
+  FInfo m_finderInfo;
+  FXInfo m_finderExtraInfo;
+};
+
+#endif
diff --git a/uriloader/exthandler/mac/nsLocalHandlerAppMac.h b/uriloader/exthandler/mac/nsLocalHandlerAppMac.h
new file mode 100644
index 0000000000..7c77091b42
--- /dev/null
+++ b/uriloader/exthandler/mac/nsLocalHandlerAppMac.h
@@ -0,0 +1,26 @@
+/* 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 NSLOCALHANDLERAPPMAC_H_
+#define NSLOCALHANDLERAPPMAC_H_
+
+#include "nsLocalHandlerApp.h"
+
+class nsLocalHandlerAppMac : public nsLocalHandlerApp {
+ public:
+  nsLocalHandlerAppMac() {}
+
+  nsLocalHandlerAppMac(const char16_t* aName, nsIFile* aExecutable)
+      : nsLocalHandlerApp(aName, aExecutable) {}
+
+  nsLocalHandlerAppMac(const nsAString& aName, nsIFile* aExecutable)
+      : nsLocalHandlerApp(aName, aExecutable) {}
+  virtual ~nsLocalHandlerAppMac() {}
+
+  NS_IMETHOD LaunchWithURI(
+      nsIURI* aURI, mozilla::dom::BrowsingContext* aBrowsingContext) override;
+  NS_IMETHOD GetName(nsAString& aName) override;
+};
+
+#endif /*NSLOCALHANDLERAPPMAC_H_*/
diff --git a/uriloader/exthandler/mac/nsLocalHandlerAppMac.mm b/uriloader/exthandler/mac/nsLocalHandlerAppMac.mm
new file mode 100644
index 0000000000..d6ad85a24e
--- /dev/null
+++ b/uriloader/exthandler/mac/nsLocalHandlerAppMac.mm
@@ -0,0 +1,78 @@
+/* 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/. */
+
+#import <CoreFoundation/CoreFoundation.h>
+#import <ApplicationServices/ApplicationServices.h>
+
+#include "nsObjCExceptions.h"
+#include "nsLocalHandlerAppMac.h"
+#include "nsILocalFileMac.h"
+#include "nsIURI.h"
+
+// We override this to make sure app bundles display their pretty name (without .app suffix)
+NS_IMETHODIMP nsLocalHandlerAppMac::GetName(nsAString& aName) {
+  if (mExecutable) {
+    nsCOMPtr<nsILocalFileMac> macFile = do_QueryInterface(mExecutable);
+    if (macFile) {
+      bool isPackage;
+      (void)macFile->IsPackage(&isPackage);
+      if (isPackage) return macFile->GetBundleDisplayName(aName);
+    }
+  }
+
+  return nsLocalHandlerApp::GetName(aName);
+}
+
+/**
+ * mostly copy/pasted from nsMacShellService.cpp (which is in browser/,
+ * so we can't depend on it here).  This code probably really wants to live
+ * somewhere more central (see bug 389922).
+ */
+NS_IMETHODIMP
+nsLocalHandlerAppMac::LaunchWithURI(nsIURI* aURI, mozilla::dom::BrowsingContext* aBrowsingContext) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+
+  nsresult rv;
+  nsCOMPtr<nsILocalFileMac> lfm(do_QueryInterface(mExecutable, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  CFURLRef appURL;
+  rv = lfm->GetCFURL(&appURL);
+  if (NS_FAILED(rv)) return rv;
+
+  nsAutoCString uriSpec;
+  aURI->GetAsciiSpec(uriSpec);
+
+  const UInt8* uriString = reinterpret_cast<const UInt8*>(uriSpec.get());
+  CFURLRef uri =
+      ::CFURLCreateWithBytes(NULL, uriString, uriSpec.Length(), kCFStringEncodingUTF8, NULL);
+  if (!uri) {
+    ::CFRelease(appURL);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  CFArrayRef uris = ::CFArrayCreate(NULL, reinterpret_cast<const void**>(&uri), 1, NULL);
+  if (!uris) {
+    ::CFRelease(uri);
+    ::CFRelease(appURL);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  LSLaunchURLSpec launchSpec;
+  launchSpec.appURL = appURL;
+  launchSpec.itemURLs = uris;
+  launchSpec.passThruParams = NULL;
+  launchSpec.launchFlags = kLSLaunchDefaults;
+  launchSpec.asyncRefCon = NULL;
+
+  OSErr err = ::LSOpenFromURLSpec(&launchSpec, NULL);
+
+  ::CFRelease(uris);
+  ::CFRelease(uri);
+  ::CFRelease(appURL);
+
+  return err != noErr ? NS_ERROR_FAILURE : NS_OK;
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
diff --git a/uriloader/exthandler/mac/nsMIMEInfoMac.h b/uriloader/exthandler/mac/nsMIMEInfoMac.h
new file mode 100644
index 0000000000..2b87601573
--- /dev/null
+++ b/uriloader/exthandler/mac/nsMIMEInfoMac.h
@@ -0,0 +1,33 @@
+/* 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 nsMIMEInfoMac_h_
+#define nsMIMEInfoMac_h_
+
+#include "nsMIMEInfoImpl.h"
+
+class nsMIMEInfoMac : public nsMIMEInfoImpl {
+ public:
+  explicit nsMIMEInfoMac(const char* aMIMEType = "")
+      : nsMIMEInfoImpl(aMIMEType) {}
+  explicit nsMIMEInfoMac(const nsACString& aMIMEType)
+      : nsMIMEInfoImpl(aMIMEType) {}
+  nsMIMEInfoMac(const nsACString& aType, HandlerClass aClass)
+      : nsMIMEInfoImpl(aType, aClass) {}
+
+  NS_IMETHOD LaunchWithFile(nsIFile* aFile) override;
+
+ protected:
+  [[nodiscard]] virtual nsresult LoadUriInternal(nsIURI* aURI) override;
+#ifdef DEBUG
+  [[nodiscard]] virtual nsresult LaunchDefaultWithFile(
+      nsIFile* aFile) override {
+    MOZ_ASSERT_UNREACHABLE("do not call this method, use LaunchWithFile");
+    return NS_ERROR_UNEXPECTED;
+  }
+#endif
+  NS_IMETHOD GetDefaultDescription(nsAString& aDefaultDescription) override;
+};
+
+#endif
diff --git a/uriloader/exthandler/mac/nsMIMEInfoMac.mm b/uriloader/exthandler/mac/nsMIMEInfoMac.mm
new file mode 100644
index 0000000000..09fe525eec
--- /dev/null
+++ b/uriloader/exthandler/mac/nsMIMEInfoMac.mm
@@ -0,0 +1,106 @@
+/* -*- 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/. */
+
+#import <ApplicationServices/ApplicationServices.h>
+
+#include "nsComponentManagerUtils.h"
+#include "nsObjCExceptions.h"
+#include "nsMIMEInfoMac.h"
+#include "nsILocalFileMac.h"
+
+// We override this to make sure app bundles display their pretty name (without .app suffix)
+NS_IMETHODIMP nsMIMEInfoMac::GetDefaultDescription(nsAString& aDefaultDescription) {
+  nsCOMPtr<nsIFile> defaultApp = GetDefaultApplication();
+  if (defaultApp) {
+    nsCOMPtr<nsILocalFileMac> macFile = do_QueryInterface(defaultApp);
+    if (macFile) {
+      bool isPackage;
+      (void)macFile->IsPackage(&isPackage);
+      if (isPackage) return macFile->GetBundleDisplayName(aDefaultDescription);
+    }
+  }
+
+  return nsMIMEInfoImpl::GetDefaultDescription(aDefaultDescription);
+}
+
+NS_IMETHODIMP
+nsMIMEInfoMac::LaunchWithFile(nsIFile* aFile) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+
+  nsCOMPtr<nsIFile> application;
+  nsresult rv;
+
+  NS_ASSERTION(mClass == eMIMEInfo, "only MIME infos are currently allowed"
+                                    "to pass content by value");
+
+  if (AutomationOnlyCheckIfLaunchStubbed(aFile)) {
+    return NS_OK;
+  }
+
+  if (mPreferredAction == useHelperApp) {
+    // we don't yet support passing content by value (rather than reference)
+    // to web apps.  at some point, we will probably want to.
+    nsCOMPtr<nsILocalHandlerApp> localHandlerApp = do_QueryInterface(mPreferredApplication, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = localHandlerApp->GetExecutable(getter_AddRefs(application));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+  } else if (mPreferredAction == useSystemDefault) {
+    application = GetDefaultApplication();
+  } else
+    return NS_ERROR_INVALID_ARG;
+
+  // if we've already got an app, just QI so we have the launchWithDoc method
+  nsCOMPtr<nsILocalFileMac> app;
+  if (application) {
+    app = do_QueryInterface(application, &rv);
+    if (NS_FAILED(rv)) return rv;
+  } else {
+    // otherwise ask LaunchServices for an app directly
+    nsCOMPtr<nsILocalFileMac> tempFile = do_QueryInterface(aFile, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    FSRef tempFileRef;
+    tempFile->GetFSRef(&tempFileRef);
+
+    FSRef appFSRef;
+    if (::LSGetApplicationForItem(&tempFileRef, kLSRolesAll, &appFSRef, nullptr) == noErr) {
+      app = (do_CreateInstance("@mozilla.org/file/local;1"));
+      if (!app) return NS_ERROR_FAILURE;
+      app->InitWithFSRef(&appFSRef);
+    } else {
+      return NS_ERROR_FAILURE;
+    }
+  }
+  return app->LaunchWithDoc(aFile, false);
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
+
+nsresult nsMIMEInfoMac::LoadUriInternal(nsIURI* aURI) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+
+  NS_ENSURE_ARG_POINTER(aURI);
+
+  nsresult rv = NS_ERROR_FAILURE;
+
+  nsAutoCString uri;
+  aURI->GetSpec(uri);
+  if (!uri.IsEmpty()) {
+    CFURLRef myURLRef = ::CFURLCreateWithBytes(kCFAllocatorDefault, (const UInt8*)uri.get(),
+                                               strlen(uri.get()), kCFStringEncodingUTF8, NULL);
+    if (myURLRef) {
+      OSStatus status = ::LSOpenCFURLRef(myURLRef, NULL);
+      if (status == noErr) rv = NS_OK;
+      ::CFRelease(myURLRef);
+    }
+  }
+
+  return rv;
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
diff --git a/uriloader/exthandler/mac/nsOSHelperAppService.h b/uriloader/exthandler/mac/nsOSHelperAppService.h
new file mode 100644
index 0000000000..aa97fee5b4
--- /dev/null
+++ b/uriloader/exthandler/mac/nsOSHelperAppService.h
@@ -0,0 +1,53 @@
+/* -*- 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. This is the Mac version.
+
+#include "nsExternalHelperAppService.h"
+#include "nsCExternalHandlerService.h"
+#include "nsCOMPtr.h"
+
+class nsIMimeInfo;
+
+class nsOSHelperAppService : public nsExternalHelperAppService {
+ public:
+  virtual ~nsOSHelperAppService();
+
+  // override nsIExternalProtocolService methods
+  NS_IMETHOD GetApplicationDescription(const nsACString& aScheme,
+                                       nsAString& _retval) override;
+
+  NS_IMETHOD IsCurrentAppOSDefaultForProtocol(const nsACString& aScheme,
+                                              bool* _retval) override;
+
+  nsresult GetMIMEInfoFromOS(const nsACString& aMIMEType,
+                             const nsACString& aFileExt, bool* aFound,
+                             nsIMIMEInfo** aMIMEInfo) override;
+
+  NS_IMETHOD GetProtocolHandlerInfoFromOS(const nsACString& aScheme,
+                                          bool* found,
+                                          nsIHandlerInfo** _retval) override;
+
+  // GetFileTokenForPath must be implemented by each platform.
+  // platformAppPath --> a platform specific path to an application that we got
+  //                     out of the rdf data source. This can be a mac file
+  //                     spec, a unix path or a windows path depending on the
+  //                     platform
+  // aFile --> an nsIFile representation of that platform application path.
+  [[nodiscard]] nsresult GetFileTokenForPath(const char16_t* platformAppPath,
+                                             nsIFile** aFile) override;
+
+  [[nodiscard]] nsresult OSProtocolHandlerExists(const char* aScheme,
+                                                 bool* aHandlerExists) override;
+};
+
+#endif  // nsOSHelperAppService_h__
diff --git a/uriloader/exthandler/mac/nsOSHelperAppService.mm b/uriloader/exthandler/mac/nsOSHelperAppService.mm
new file mode 100644
index 0000000000..3de5c1871b
--- /dev/null
+++ b/uriloader/exthandler/mac/nsOSHelperAppService.mm
@@ -0,0 +1,589 @@
+/* -*- 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 <sys/types.h>
+#include <sys/stat.h>
+#include "mozilla/net/NeckoCommon.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "nsComponentManagerUtils.h"
+#include "nsOSHelperAppService.h"
+#include "nsObjCExceptions.h"
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsIFile.h"
+#include "nsILocalFileMac.h"
+#include "nsMimeTypes.h"
+#include "nsCRT.h"
+#include "nsMIMEInfoMac.h"
+#include "nsEmbedCID.h"
+
+#import <CoreFoundation/CoreFoundation.h>
+#import <ApplicationServices/ApplicationServices.h>
+
+// chrome URL's
+#define HELPERAPPLAUNCHER_BUNDLE_URL "chrome://global/locale/helperAppLauncher.properties"
+#define BRAND_BUNDLE_URL "chrome://branding/locale/brand.properties"
+
+nsresult GetDefaultBundleURL(const nsACString& aScheme, CFURLRef* aBundleURL) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+
+  nsresult rv = NS_ERROR_NOT_AVAILABLE;
+
+  CFStringRef schemeCFString = ::CFStringCreateWithBytes(
+      kCFAllocatorDefault, (const UInt8*)PromiseFlatCString(aScheme).get(), aScheme.Length(),
+      kCFStringEncodingUTF8, false);
+
+  if (schemeCFString) {
+    CFStringRef lookupCFString =
+        ::CFStringCreateWithFormat(NULL, NULL, CFSTR("%@:"), schemeCFString);
+
+    if (lookupCFString) {
+      CFURLRef lookupCFURL = ::CFURLCreateWithString(NULL, lookupCFString, NULL);
+
+      if (lookupCFURL) {
+        if (@available(macOS 10.10, *)) {
+          *aBundleURL = ::LSCopyDefaultApplicationURLForURL(lookupCFURL, kLSRolesAll, NULL);
+          if (*aBundleURL) {
+            rv = NS_OK;
+          }
+        } else {
+          OSStatus theErr = ::LSGetApplicationForURL(lookupCFURL, kLSRolesAll, NULL, aBundleURL);
+          if (theErr == noErr && *aBundleURL) {
+            rv = NS_OK;
+          }
+        }
+
+        ::CFRelease(lookupCFURL);
+      }
+
+      ::CFRelease(lookupCFString);
+    }
+
+    ::CFRelease(schemeCFString);
+  }
+
+  return rv;
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
+
+using mozilla::LogLevel;
+
+/* This is an undocumented interface (in the Foundation framework) that has
+ * been stable since at least 10.2.8 and is still present on SnowLeopard.
+ * Furthermore WebKit has three public methods (in WebKitSystemInterface.h)
+ * that are thin wrappers around this interface's last three methods.  So
+ * it's unlikely to change anytime soon.  Now that we're no longer using
+ * Internet Config Services, this is the only way to look up a MIME type
+ * from an extension, or vice versa.
+ */
+@class NSURLFileTypeMappingsInternal;
+
+@interface NSURLFileTypeMappings : NSObject {
+  NSURLFileTypeMappingsInternal* _internal;
+}
+
++ (NSURLFileTypeMappings*)sharedMappings;
+- (NSString*)MIMETypeForExtension:(NSString*)aString;
+- (NSString*)preferredExtensionForMIMEType:(NSString*)aString;
+- (NSArray*)extensionsForMIMEType:(NSString*)aString;
+@end
+
+nsOSHelperAppService::~nsOSHelperAppService() {}
+
+nsresult nsOSHelperAppService::OSProtocolHandlerExists(const char* aProtocolScheme,
+                                                       bool* aHandlerExists) {
+  // CFStringCreateWithBytes() can fail even if we're not out of memory --
+  // for example if the 'bytes' parameter is something very weird (like
+  // "\xFF\xFF~"), or possibly if it can't be interpreted as using what's
+  // specified in the 'encoding' parameter.  See bug 548719.
+  CFStringRef schemeString =
+      ::CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8*)aProtocolScheme,
+                                strlen(aProtocolScheme), kCFStringEncodingUTF8, false);
+  if (schemeString) {
+    // LSCopyDefaultHandlerForURLScheme() can fail to find the default handler
+    // for aProtocolScheme when it's never been explicitly set (using
+    // LSSetDefaultHandlerForURLScheme()).  For example, Safari is the default
+    // handler for the "http" scheme on a newly installed copy of OS X.  But
+    // this (presumably) wasn't done using LSSetDefaultHandlerForURLScheme(),
+    // so LSCopyDefaultHandlerForURLScheme() will fail to find Safari.  To get
+    // around this we use LSCopyAllHandlersForURLScheme() instead -- which seems
+    // never to fail.
+    // http://lists.apple.com/archives/Carbon-dev/2007/May/msg00349.html
+    // http://www.realsoftware.com/listarchives/realbasic-nug/2008-02/msg00119.html
+    CFArrayRef handlerArray = ::LSCopyAllHandlersForURLScheme(schemeString);
+    *aHandlerExists = !!handlerArray;
+    if (handlerArray) ::CFRelease(handlerArray);
+    ::CFRelease(schemeString);
+  } else {
+    *aHandlerExists = false;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsOSHelperAppService::GetApplicationDescription(const nsACString& aScheme,
+                                                              nsAString& _retval) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+
+  nsresult rv = NS_ERROR_NOT_AVAILABLE;
+
+  CFURLRef handlerBundleURL;
+  rv = GetDefaultBundleURL(aScheme, &handlerBundleURL);
+
+  if (NS_SUCCEEDED(rv) && handlerBundleURL) {
+    CFBundleRef handlerBundle = CFBundleCreate(NULL, handlerBundleURL);
+    if (!handlerBundle) {
+      ::CFRelease(handlerBundleURL);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    // Get the human-readable name of the bundle
+    CFStringRef bundleName =
+        (CFStringRef)::CFBundleGetValueForInfoDictionaryKey(handlerBundle, kCFBundleNameKey);
+
+    if (bundleName) {
+      AutoTArray<UniChar, 255> buffer;
+      CFIndex bundleNameLength = ::CFStringGetLength(bundleName);
+      buffer.SetLength(bundleNameLength);
+      ::CFStringGetCharacters(bundleName, CFRangeMake(0, bundleNameLength), buffer.Elements());
+      _retval.Assign(reinterpret_cast<char16_t*>(buffer.Elements()), bundleNameLength);
+      rv = NS_OK;
+    }
+    ::CFRelease(handlerBundle);
+    ::CFRelease(handlerBundleURL);
+  }
+
+  return rv;
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
+
+NS_IMETHODIMP nsOSHelperAppService::IsCurrentAppOSDefaultForProtocol(const nsACString& aScheme,
+                                                                     bool* _retval) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+
+  nsresult rv = NS_ERROR_NOT_AVAILABLE;
+
+  CFURLRef handlerBundleURL;
+  rv = GetDefaultBundleURL(aScheme, &handlerBundleURL);
+  if (NS_SUCCEEDED(rv) && handlerBundleURL) {
+    // Ensure we don't accidentally return success if we can't get an app bundle.
+    rv = NS_ERROR_NOT_AVAILABLE;
+    CFBundleRef appBundle = ::CFBundleGetMainBundle();
+    if (appBundle) {
+      CFURLRef selfURL = ::CFBundleCopyBundleURL(appBundle);
+      *_retval = ::CFEqual(selfURL, handlerBundleURL);
+      rv = NS_OK;
+      ::CFRelease(selfURL);
+    }
+    ::CFRelease(handlerBundleURL);
+  }
+
+  return rv;
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
+
+nsresult nsOSHelperAppService::GetFileTokenForPath(const char16_t* aPlatformAppPath,
+                                                   nsIFile** aFile) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+
+  nsresult rv;
+  nsCOMPtr<nsILocalFileMac> localFile(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  CFURLRef pathAsCFURL;
+  CFStringRef pathAsCFString = ::CFStringCreateWithCharacters(
+      NULL, reinterpret_cast<const UniChar*>(aPlatformAppPath), NS_strlen(aPlatformAppPath));
+  if (!pathAsCFString) return NS_ERROR_OUT_OF_MEMORY;
+
+  if (::CFStringGetCharacterAtIndex(pathAsCFString, 0) == '/') {
+    // we have a Posix path
+    pathAsCFURL =
+        ::CFURLCreateWithFileSystemPath(nullptr, pathAsCFString, kCFURLPOSIXPathStyle, false);
+    if (!pathAsCFURL) {
+      ::CFRelease(pathAsCFString);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+  } else {
+    // if it doesn't start with a / it's not an absolute Posix path
+    // let's check if it's a HFS path left over from old preferences
+
+    // If it starts with a ':' char, it's not an absolute HFS path
+    // so bail for that, and also if it's empty
+    if (::CFStringGetLength(pathAsCFString) == 0 ||
+        ::CFStringGetCharacterAtIndex(pathAsCFString, 0) == ':') {
+      ::CFRelease(pathAsCFString);
+      return NS_ERROR_FILE_UNRECOGNIZED_PATH;
+    }
+
+    pathAsCFURL =
+        ::CFURLCreateWithFileSystemPath(nullptr, pathAsCFString, kCFURLHFSPathStyle, false);
+    if (!pathAsCFURL) {
+      ::CFRelease(pathAsCFString);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+  }
+
+  rv = localFile->InitWithCFURL(pathAsCFURL);
+  ::CFRelease(pathAsCFString);
+  ::CFRelease(pathAsCFURL);
+  if (NS_FAILED(rv)) return rv;
+  *aFile = localFile;
+  NS_IF_ADDREF(*aFile);
+
+  return NS_OK;
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
+
+// Returns the MIME types an application bundle explicitly claims to handle.
+// Returns NULL if aAppRef doesn't explicitly claim to handle any MIME types.
+// If the return value is non-NULL, the caller is responsible for freeing it.
+// This isn't necessarily the same as the MIME types the application bundle
+// is registered to handle in the Launch Services database.  (For example
+// the Preview application is normally registered to handle the application/pdf
+// MIME type, even though it doesn't explicitly claim to handle *any* MIME
+// types in its Info.plist.  This is probably because Preview does explicitly
+// claim to handle the com.adobe.pdf UTI, and Launch Services somehow
+// translates this into a claim to support the application/pdf MIME type.
+// Launch Services doesn't provide any APIs (documented or undocumented) to
+// query which MIME types a given application is registered to handle.  So any
+// app that wants this information (e.g. the Default Apps pref pane) needs to
+// iterate through the entire Launch Services database -- a process which can
+// take several seconds.)
+static CFArrayRef GetMIMETypesHandledByApp(FSRef* aAppRef) {
+  CFURLRef appURL = ::CFURLCreateFromFSRef(kCFAllocatorDefault, aAppRef);
+  if (!appURL) {
+    return NULL;
+  }
+  CFDictionaryRef infoDict = ::CFBundleCopyInfoDictionaryForURL(appURL);
+  ::CFRelease(appURL);
+  if (!infoDict) {
+    return NULL;
+  }
+  CFTypeRef cfObject = ::CFDictionaryGetValue(infoDict, CFSTR("CFBundleDocumentTypes"));
+  if (!cfObject || (::CFGetTypeID(cfObject) != ::CFArrayGetTypeID())) {
+    ::CFRelease(infoDict);
+    return NULL;
+  }
+
+  CFArrayRef docTypes = static_cast<CFArrayRef>(cfObject);
+  CFIndex docTypesCount = ::CFArrayGetCount(docTypes);
+  if (docTypesCount == 0) {
+    ::CFRelease(infoDict);
+    return NULL;
+  }
+
+  CFMutableArrayRef mimeTypes =
+      ::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
+  for (CFIndex i = 0; i < docTypesCount; ++i) {
+    cfObject = ::CFArrayGetValueAtIndex(docTypes, i);
+    if (!cfObject || (::CFGetTypeID(cfObject) != ::CFDictionaryGetTypeID())) {
+      continue;
+    }
+    CFDictionaryRef typeDict = static_cast<CFDictionaryRef>(cfObject);
+
+    // When this key is present (on OS X 10.5 and later), its contents
+    // take precedence over CFBundleTypeMIMETypes (and CFBundleTypeExtensions
+    // and CFBundleTypeOSTypes).
+    cfObject = ::CFDictionaryGetValue(typeDict, CFSTR("LSItemContentTypes"));
+    if (cfObject && (::CFGetTypeID(cfObject) == ::CFArrayGetTypeID())) {
+      continue;
+    }
+
+    cfObject = ::CFDictionaryGetValue(typeDict, CFSTR("CFBundleTypeMIMETypes"));
+    if (!cfObject || (::CFGetTypeID(cfObject) != ::CFArrayGetTypeID())) {
+      continue;
+    }
+    CFArrayRef mimeTypeHolder = static_cast<CFArrayRef>(cfObject);
+    CFArrayAppendArray(mimeTypes, mimeTypeHolder,
+                       ::CFRangeMake(0, ::CFArrayGetCount(mimeTypeHolder)));
+  }
+
+  ::CFRelease(infoDict);
+  if (!::CFArrayGetCount(mimeTypes)) {
+    ::CFRelease(mimeTypes);
+    mimeTypes = NULL;
+  }
+  return mimeTypes;
+}
+
+nsresult nsOSHelperAppService::GetMIMEInfoFromOS(const nsACString& aMIMEType,
+                                                 const nsACString& aFileExt, bool* aFound,
+                                                 nsIMIMEInfo** aMIMEInfo) {
+  NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  *aFound = false;
+
+  const nsCString& flatType = PromiseFlatCString(aMIMEType);
+  const nsCString& flatExt = PromiseFlatCString(aFileExt);
+
+  MOZ_LOG(sLog, LogLevel::Debug,
+          ("Mac: HelperAppService lookup for type '%s' ext '%s'\n", flatType.get(), flatExt.get()));
+
+  // Create a Mac-specific MIME info so we can use Mac-specific members.
+  RefPtr<nsMIMEInfoMac> mimeInfoMac = new nsMIMEInfoMac(aMIMEType);
+
+  NSAutoreleasePool* localPool = [[NSAutoreleasePool alloc] init];
+
+  OSStatus err;
+  bool haveAppForType = false;
+  bool haveAppForExt = false;
+  bool typeIsOctetStream = false;
+  bool typeAppIsDefault = false;
+  bool extAppIsDefault = false;
+  FSRef typeAppFSRef;
+  FSRef extAppFSRef;
+
+  CFStringRef cfMIMEType = NULL;
+
+  if (!aMIMEType.IsEmpty()) {
+    typeIsOctetStream = aMIMEType.LowerCaseEqualsLiteral(APPLICATION_OCTET_STREAM);
+    CFURLRef appURL = NULL;
+    // CFStringCreateWithCString() can fail even if we're not out of memory --
+    // for example if the 'cStr' parameter is something very weird (like
+    // "\xFF\xFF~"), or possibly if it can't be interpreted as using what's
+    // specified in the 'encoding' parameter.  See bug 548719.
+    cfMIMEType = ::CFStringCreateWithCString(NULL, flatType.get(), kCFStringEncodingUTF8);
+    if (cfMIMEType) {
+      err = ::LSCopyApplicationForMIMEType(cfMIMEType, kLSRolesAll, &appURL);
+      if ((err == noErr) && appURL && ::CFURLGetFSRef(appURL, &typeAppFSRef)) {
+        haveAppForType = true;
+        MOZ_LOG(sLog, LogLevel::Debug,
+                ("LSCopyApplicationForMIMEType found a default application\n"));
+      }
+      if (appURL) {
+        ::CFRelease(appURL);
+      }
+    }
+  }
+  if (!aFileExt.IsEmpty()) {
+    // CFStringCreateWithCString() can fail even if we're not out of memory --
+    // for example if the 'cStr' parameter is something very weird (like
+    // "\xFF\xFF~"), or possibly if it can't be interpreted as using what's
+    // specified in the 'encoding' parameter.  See bug 548719.
+    CFStringRef cfExt = ::CFStringCreateWithCString(NULL, flatExt.get(), kCFStringEncodingUTF8);
+    if (cfExt) {
+      err = ::LSGetApplicationForInfo(kLSUnknownType, kLSUnknownCreator, cfExt, kLSRolesAll,
+                                      &extAppFSRef, nullptr);
+      if (err == noErr) {
+        haveAppForExt = true;
+        MOZ_LOG(sLog, LogLevel::Debug, ("LSGetApplicationForInfo found a default application\n"));
+      }
+      ::CFRelease(cfExt);
+    }
+  }
+
+  if (haveAppForType && haveAppForExt) {
+    // Do aMIMEType and aFileExt match?
+    if (::FSCompareFSRefs((const FSRef*)&typeAppFSRef, (const FSRef*)&extAppFSRef) == noErr) {
+      typeAppIsDefault = true;
+      *aFound = true;
+    }
+  } else if (haveAppForType) {
+    // If aFileExt isn't empty, it doesn't match aMIMEType.
+    if (aFileExt.IsEmpty()) {
+      typeAppIsDefault = true;
+      *aFound = true;
+    }
+  }
+
+  // If we have an app for the extension, and either don't have one for the
+  // type, or the type is application/octet-stream (ie "binary blob"), rely
+  // on the file extension.
+  if ((!haveAppForType || (!*aFound && typeIsOctetStream)) && haveAppForExt) {
+    // If aMIMEType isn't empty, it doesn't match aFileExt, which should mean
+    // that we haven't found a matching app.  But make an exception for an app
+    // that also explicitly claims to handle aMIMEType, or which doesn't claim
+    // to handle any MIME types.  This helps work around the following Apple
+    // design flaw:
+    //
+    // Launch Services is somewhat unreliable about registering Apple apps to
+    // handle MIME types.  Probably this is because Apple has officially
+    // deprecated support for MIME types (in favor of UTIs).  As a result,
+    // most of Apple's own apps don't explicitly claim to handle any MIME
+    // types (instead they claim to handle one or more UTIs).  So Launch
+    // Services must contain logic to translate support for a given UTI into
+    // support for one or more MIME types, and it doesn't always do this
+    // correctly.  For example DiskImageMounter isn't (by default) registered
+    // to handle the application/x-apple-diskimage MIME type.  See bug 675356.
+    //
+    // Apple has also deprecated support for file extensions, and Apple apps
+    // also don't register to handle them.  But for some reason Launch Services
+    // is (apparently) better about translating support for a given UTI into
+    // support for one or more file extensions.  It's not at all clear why.
+    if (aMIMEType.IsEmpty() || typeIsOctetStream) {
+      extAppIsDefault = true;
+      *aFound = true;
+    } else {
+      CFArrayRef extAppMIMETypes = GetMIMETypesHandledByApp(&extAppFSRef);
+      if (extAppMIMETypes) {
+        if (cfMIMEType) {
+          if (::CFArrayContainsValue(extAppMIMETypes,
+                                     ::CFRangeMake(0, ::CFArrayGetCount(extAppMIMETypes)),
+                                     cfMIMEType)) {
+            extAppIsDefault = true;
+            *aFound = true;
+          }
+        }
+        ::CFRelease(extAppMIMETypes);
+      } else {
+        extAppIsDefault = true;
+        *aFound = true;
+      }
+    }
+  }
+
+  if (cfMIMEType) {
+    ::CFRelease(cfMIMEType);
+  }
+
+  if (aMIMEType.IsEmpty()) {
+    if (haveAppForExt) {
+      // If aMIMEType is empty and we've found a default app for aFileExt, try
+      // to get the MIME type from aFileExt.  (It might also be worth doing
+      // this when aMIMEType isn't empty but haveAppForType is false -- but
+      // the doc for this method says that if we have a MIME type (in
+      // aMIMEType), we need to give it preference.)
+      NSURLFileTypeMappings* map = [NSURLFileTypeMappings sharedMappings];
+      NSString* extStr = [NSString stringWithCString:flatExt.get() encoding:NSASCIIStringEncoding];
+      NSString* typeStr = map ? [map MIMETypeForExtension:extStr] : NULL;
+      if (typeStr) {
+        nsAutoCString mimeType;
+        mimeType.Assign((char*)[typeStr cStringUsingEncoding:NSASCIIStringEncoding]);
+        mimeInfoMac->SetMIMEType(mimeType);
+        haveAppForType = true;
+      } else {
+        // Sometimes the OS won't give us a MIME type for an extension that's
+        // registered with Launch Services and has a default app:  For example
+        // Real Player registers itself for the "ogg" extension and for the
+        // audio/x-ogg and application/x-ogg MIME types, but
+        // MIMETypeForExtension returns nil for the "ogg" extension even on
+        // systems where Real Player is installed.  This is probably an Apple
+        // bug.  But bad things happen if we return an nsIMIMEInfo structure
+        // with an empty MIME type and set *aFound to true.  So in this
+        // case we need to set it to false here.
+        haveAppForExt = false;
+        extAppIsDefault = false;
+        *aFound = false;
+      }
+    } else {
+      // Otherwise set the MIME type to a reasonable fallback.
+      mimeInfoMac->SetMIMEType(nsLiteralCString(APPLICATION_OCTET_STREAM));
+    }
+  }
+
+  if (typeAppIsDefault || extAppIsDefault) {
+    if (haveAppForExt) mimeInfoMac->AppendExtension(aFileExt);
+
+    nsresult rv;
+    nsCOMPtr<nsILocalFileMac> app(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
+    if (NS_FAILED(rv)) {
+      [localPool release];
+      return rv;
+    }
+
+    CFStringRef cfAppName = NULL;
+    if (typeAppIsDefault) {
+      app->InitWithFSRef(&typeAppFSRef);
+      ::LSCopyItemAttribute((const FSRef*)&typeAppFSRef, kLSRolesAll, kLSItemDisplayName,
+                            (CFTypeRef*)&cfAppName);
+    } else {
+      app->InitWithFSRef(&extAppFSRef);
+      ::LSCopyItemAttribute((const FSRef*)&extAppFSRef, kLSRolesAll, kLSItemDisplayName,
+                            (CFTypeRef*)&cfAppName);
+    }
+    if (cfAppName) {
+      AutoTArray<UniChar, 255> buffer;
+      CFIndex appNameLength = ::CFStringGetLength(cfAppName);
+      buffer.SetLength(appNameLength);
+      ::CFStringGetCharacters(cfAppName, CFRangeMake(0, appNameLength), buffer.Elements());
+      nsAutoString appName;
+      appName.Assign(reinterpret_cast<char16_t*>(buffer.Elements()), appNameLength);
+      mimeInfoMac->SetDefaultDescription(appName);
+      ::CFRelease(cfAppName);
+    }
+
+    mimeInfoMac->SetDefaultApplication(app);
+    mimeInfoMac->SetPreferredAction(nsIMIMEInfo::saveToDisk);
+
+  } else {
+    mimeInfoMac->SetPreferredAction(nsIMIMEInfo::saveToDisk);
+  }
+
+  nsAutoCString mimeType;
+  mimeInfoMac->GetMIMEType(mimeType);
+  if (*aFound && !mimeType.IsEmpty()) {
+    // If we have a MIME type, make sure its extension list is included in our
+    // list.
+    NSURLFileTypeMappings* map = [NSURLFileTypeMappings sharedMappings];
+    NSString* typeStr = [NSString stringWithCString:mimeType.get() encoding:NSASCIIStringEncoding];
+    NSArray* extensionsList = map ? [map extensionsForMIMEType:typeStr] : NULL;
+    if (extensionsList) {
+      for (NSString* extension in extensionsList) {
+        nsAutoCString ext;
+        ext.Assign((char*)[extension cStringUsingEncoding:NSASCIIStringEncoding]);
+        mimeInfoMac->AppendExtension(ext);
+      }
+    }
+
+    if (CFStringRef cfType =
+            ::CFStringCreateWithCString(NULL, mimeType.get(), kCFStringEncodingUTF8)) {
+      if (CFStringRef cfTypeDesc = ::UTTypeCopyDescription(cfType)) {
+        AutoTArray<UniChar, 255> buffer;
+        CFIndex typeDescLength = ::CFStringGetLength(cfTypeDesc);
+        buffer.SetLength(typeDescLength);
+        ::CFStringGetCharacters(cfTypeDesc, CFRangeMake(0, typeDescLength), buffer.Elements());
+        nsAutoString typeDesc;
+        typeDesc.Assign(reinterpret_cast<char16_t*>(buffer.Elements()), typeDescLength);
+        mimeInfoMac->SetDescription(typeDesc);
+        ::CFRelease(cfTypeDesc);
+      }
+      ::CFRelease(cfType);
+    }
+  }
+
+  MOZ_LOG(sLog, LogLevel::Debug, ("OS gave us: type '%s' found '%i'\n", mimeType.get(), *aFound));
+
+  [localPool release];
+  mimeInfoMac.forget(aMIMEInfo);
+  return NS_OK;
+
+  NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE);
+}
+
+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;
+
+  nsMIMEInfoMac* handlerInfo = new nsMIMEInfoMac(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;
+  }
+
+  // As a workaround for the OS X problem described in bug 1391186, don't
+  // attempt to get/set the application description from the child process.
+  if (!mozilla::net::IsNeckoChild()) {
+    nsAutoString desc;
+    rv = GetApplicationDescription(aScheme, desc);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "GetApplicationDescription failed");
+    handlerInfo->SetDefaultDescription(desc);
+  }
+
+  return NS_OK;
+}