wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-08-15 08:53:07 +09:00
Code Issues Projects Releases Packages Wiki Activity

Merge remote-tracking branch 'origin/master' into custom

Browse source
This commit is contained in:
roytam1 2021-06-24 11:13:09 +08:00
commit 20c6498ca1
395 changed files with 818 additions and 23422 deletions
Download patch file Download diff file Expand all files Collapse all files

389
uriloader/exthandler/mac/nsDecodeAppleFile.cpp
View file

@ -1,389 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 "prmem.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_THREADSAFE
nsDecodeAppleFile::nsDecodeAppleFile()
{
m_state = parseHeaders;
m_dataBufferLength = 0;
m_dataBuffer = (unsigned char*) PR_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()
{
PR_FREEIF(m_dataBuffer);
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::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;
}

118
uriloader/exthandler/mac/nsDecodeAppleFile.h
View file

@ -1,118 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 "nsILocalFileMac.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();
MOZ_MUST_USE 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

26
uriloader/exthandler/mac/nsLocalHandlerAppMac.h
View file

@ -1,26 +0,0 @@
/* 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, nsIInterfaceRequestor* aWindowContext);
NS_IMETHOD GetName(nsAString& aName);
};
#endif /*NSLOCALHANDLERAPPMAC_H_*/

84
uriloader/exthandler/mac/nsLocalHandlerAppMac.mm
View file

@ -1,84 +0,0 @@
/* 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,
nsIInterfaceRequestor *aWindowContext)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
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_ABORT_BLOCK_NSRESULT;
}

34
uriloader/exthandler/mac/nsMIMEInfoMac.h
View file

@ -1,34 +0,0 @@
/* 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);
protected:
virtual MOZ_MUST_USE nsresult LoadUriInternal(nsIURI *aURI);
#ifdef DEBUG
virtual MOZ_MUST_USE nsresult LaunchDefaultWithFile(nsIFile* aFile) {
NS_NOTREACHED("do not call this method, use LaunchWithFile");
return NS_ERROR_UNEXPECTED;
}
#endif
static MOZ_MUST_USE nsresult OpenApplicationWithURI(nsIFile *aApplication,
const nsCString& aURI);
NS_IMETHOD GetDefaultDescription(nsAString& aDefaultDescription);
};
#endif

114
uriloader/exthandler/mac/nsMIMEInfoMac.mm
View file

@ -1,114 +0,0 @@
/* -*- 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 "nsObjCExceptions.h"
#include "nsMIMEInfoMac.h"
#include "nsILocalFileMac.h"
#include "nsIFileURL.h"
// We override this to make sure app bundles display their pretty name (without .app suffix)
NS_IMETHODIMP nsMIMEInfoMac::GetDefaultDescription(nsAString& aDefaultDescription)
{
if (mDefaultApplication) {
nsCOMPtr<nsILocalFileMac> macFile = do_QueryInterface(mDefaultApplication);
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_ABORT_BLOCK_NSRESULT;
nsCOMPtr<nsIFile> application;
nsresult rv;
NS_ASSERTION(mClass == eMIMEInfo, "only MIME infos are currently allowed"
"to pass content by value");
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 = mDefaultApplication;
}
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_ABORT_BLOCK_NSRESULT;
}
nsresult
nsMIMEInfoMac::LoadUriInternal(nsIURI *aURI)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
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_ABORT_BLOCK_NSRESULT;
}

48
uriloader/exthandler/mac/nsOSHelperAppService.h
View file

@ -1,48 +0,0 @@
/* -*- 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 "nsMIMEInfoImpl.h"
#include "nsCOMPtr.h"
class nsOSHelperAppService : public nsExternalHelperAppService
{
public:
nsOSHelperAppService();
virtual ~nsOSHelperAppService();
// override nsIExternalProtocolService methods
NS_IMETHOD GetApplicationDescription(const nsACString& aScheme, nsAString& _retval);
// method overrides --> used to hook the mime service into internet config....
NS_IMETHOD GetFromTypeAndExtension(const nsACString& aType, const nsACString& aFileExt, nsIMIMEInfo ** aMIMEInfo);
already_AddRefed<nsIMIMEInfo> GetMIMEInfoFromOS(const nsACString& aMIMEType, const nsACString& aFileExt, bool * aFound);
NS_IMETHOD GetProtocolHandlerInfoFromOS(const nsACString &aScheme,
bool *found,
nsIHandlerInfo **_retval);
// 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.
virtual MOZ_MUST_USE nsresult GetFileTokenForPath(const char16_t * platformAppPath, nsIFile ** aFile);
MOZ_MUST_USE nsresult OSProtocolHandlerExists(const char * aScheme,
bool * aHandlerExists);
private:
uint32_t mPermissions;
};
#endif // nsOSHelperAppService_h__

569
uriloader/exthandler/mac/nsOSHelperAppService.mm
View file

@ -1,569 +0,0 @@
/* -*- 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 "nsOSHelperAppService.h"
#include "nsObjCExceptions.h"
#include "nsISupports.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsXPIDLString.h"
#include "nsIURL.h"
#include "nsIFile.h"
#include "nsILocalFileMac.h"
#include "nsMimeTypes.h"
#include "nsIStringBundle.h"
#include "nsIPromptService.h"
#include "nsMemory.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"
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() : nsExternalHelperAppService()
{
mode_t mask = umask(0777);
umask(mask);
mPermissions = 0666 & ~mask;
}
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 wierd (like "ÿÿ~"
// aka "\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_ABORT_BLOCK_NSRESULT;
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) {
CFURLRef appCFURL = NULL;
OSStatus theErr = ::LSGetApplicationForURL(lookupCFURL, kLSRolesAll, NULL, &appCFURL);
if (theErr == noErr) {
CFBundleRef handlerBundle = ::CFBundleCreate(NULL, appCFURL);
if (handlerBundle) {
// Get the human-readable name of the default handler 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(appCFURL);
}
::CFRelease(lookupCFURL);
}
::CFRelease(lookupCFString);
}
::CFRelease(schemeCFString);
}
return rv;
NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
}
nsresult nsOSHelperAppService::GetFileTokenForPath(const char16_t * aPlatformAppPath, nsIFile ** aFile)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
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_ABORT_BLOCK_NSRESULT;
}
NS_IMETHODIMP nsOSHelperAppService::GetFromTypeAndExtension(const nsACString& aType, const nsACString& aFileExt, nsIMIMEInfo ** aMIMEInfo)
{
return nsExternalHelperAppService::GetFromTypeAndExtension(aType, aFileExt, aMIMEInfo);
}
// 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;
}
// aMIMEType and aFileExt might not match, If they don't we set *aFound to
// false and return a minimal nsIMIMEInfo structure.
already_AddRefed<nsIMIMEInfo>
nsOSHelperAppService::GetMIMEInfoFromOS(const nsACString& aMIMEType,
const nsACString& aFileExt,
bool * aFound)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSNULL;
*aFound = false;
const nsCString& flatType = PromiseFlatCString(aMIMEType);
const nsCString& flatExt = PromiseFlatCString(aFileExt);
MOZ_LOG(mLog, 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 typeAppIsDefault = false;
bool extAppIsDefault = false;
FSRef typeAppFSRef;
FSRef extAppFSRef;
CFStringRef cfMIMEType = NULL;
if (!aMIMEType.IsEmpty()) {
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 "ÿÿ~"
// aka "\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(mLog, 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 wierd (like "ÿÿ~"
// aka "\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(mLog, 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;
}
} else if (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()) {
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(NS_LITERAL_CSTRING(APPLICATION_OCTET_STREAM));
}
}
if (typeAppIsDefault || extAppIsDefault) {
if (haveAppForExt)
mimeInfoMac->AppendExtension(aFileExt);
nsCOMPtr<nsILocalFileMac> app(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
if (!app) {
[localPool release];
return nullptr;
}
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::useSystemDefault);
} else {
mimeInfoMac->SetPreferredAction(nsIMIMEInfo::saveToDisk);
}
nsAutoCString mimeType;
mimeInfoMac->GetMIMEType(mimeType);
if (*aFound && !mimeType.IsEmpty()) {
// If we have a MIME type, make sure its preferred extension is included
// in our list.
NSURLFileTypeMappings *map = [NSURLFileTypeMappings sharedMappings];
NSString *typeStr = [NSString stringWithCString:mimeType.get() encoding:NSASCIIStringEncoding];
NSString *extStr = map ? [map preferredExtensionForMIMEType:typeStr] : NULL;
if (extStr) {
nsAutoCString preferredExt;
preferredExt.Assign((char *)[extStr cStringUsingEncoding:NSASCIIStringEncoding]);
mimeInfoMac->AppendExtension(preferredExt);
}
CFStringRef cfType = ::CFStringCreateWithCString(NULL, mimeType.get(), kCFStringEncodingUTF8);
if (cfType) {
CFStringRef cfTypeDesc = NULL;
if (::LSCopyKindStringForMIMEType(cfType, &cfTypeDesc) == noErr) {
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);
}
if (cfTypeDesc) {
::CFRelease(cfTypeDesc);
}
::CFRelease(cfType);
}
}
MOZ_LOG(mLog, LogLevel::Debug, ("OS gave us: type '%s' found '%i'\n", mimeType.get(), *aFound));
[localPool release];
return mimeInfoMac.forget();
NS_OBJC_END_TRY_ABORT_BLOCK_NSNULL;
}
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;
}
nsAutoString desc;
rv = GetApplicationDescription(aScheme, desc);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "GetApplicationDescription failed");
handlerInfo->SetDefaultDescription(desc);
return NS_OK;
}

10
uriloader/exthandler/moz.build
View file

@ -21,8 +21,6 @@ XPIDL_MODULE = 'exthandler'
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
osdir = 'win'
LOCAL_INCLUDES += ['win']
elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
osdir = 'mac'
elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'uikit':
osdir = 'uikit'
else:
@ -53,13 +51,7 @@ UNIFIED_SOURCES += [
'nsMIMEInfoImpl.cpp',
]
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
UNIFIED_SOURCES += [
'mac/nsLocalHandlerAppMac.mm',
'mac/nsMIMEInfoMac.mm',
'mac/nsOSHelperAppService.mm',
]
elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'uikit':
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'uikit':
UNIFIED_SOURCES += [
'uikit/nsLocalHandlerAppUIKit.mm',
'uikit/nsMIMEInfoUIKit.mm',