nsresult
nsFileView::Init()
{
mDirectoryAtom = do_GetAtom("directory");
if (!mDirectoryAtom)
return NS_ERROR_OUT_OF_MEMORY;
mFileAtom = do_GetAtom("file");
if (!mFileAtom)
return NS_ERROR_OUT_OF_MEMORY;
NS_NewISupportsArray(getter_AddRefs(mFileList));
if (!mFileList)
return NS_ERROR_OUT_OF_MEMORY;
NS_NewISupportsArray(getter_AddRefs(mDirList));
if (!mDirList)
return NS_ERROR_OUT_OF_MEMORY;
NS_NewISupportsArray(getter_AddRefs(mFilteredFiles));
if (!mFilteredFiles)
return NS_ERROR_OUT_OF_MEMORY;
mDateFormatter = do_CreateInstance(NS_DATETIMEFORMAT_CONTRACTID);
if (!mDateFormatter)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
nsresult nsEudoraFilters::LoadServers()
{
nsresult rv;
if (m_pServerArray)
rv = m_pServerArray->Clear();
else
rv = NS_NewISupportsArray(getter_AddRefs(m_pServerArray));
NS_ENSURE_SUCCESS(rv, rv);
if (!m_pFilterArray)
rv = NS_NewISupportsArray(getter_AddRefs(m_pFilterArray));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgAccountManager> accountMgr = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupportsArray> allServers;
rv = accountMgr->GetAllServers(getter_AddRefs(allServers));
NS_ENSURE_SUCCESS(rv, rv);
uint32_t numServers;
rv = allServers->Count(&numServers);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t serverIndex = 0; serverIndex < numServers; serverIndex++)
{
nsCOMPtr<nsIMsgIncomingServer> server = do_QueryElementAt(allServers, serverIndex, &rv);
if (server && NS_SUCCEEDED(rv))
{
bool canHaveFilters;
rv = server->GetCanHaveFilters(&canHaveFilters);
if (NS_SUCCEEDED(rv) && canHaveFilters)
{
nsAutoCString serverType;
rv = server->GetType(serverType);
if (NS_SUCCEEDED(rv) && !serverType.IsEmpty())
{
// Only get imap accounts and the special "none" (Local Folders) account
// since all imported Eudora pop3 accounts will go to Local Folders
if (serverType.Equals("none") || serverType.Equals("imap"))
{
// Pre-fetch filters now so that if there's any problem reading up the
// filter file we know about it in advance and can stop importing
nsCOMPtr<nsIMsgFilterList> filterList;
rv = server->GetFilterList(nullptr, getter_AddRefs(filterList));
NS_ENSURE_SUCCESS(rv, rv);
m_pServerArray->AppendElement(server);
}
}
}
}
}
return NS_OK;
}
nsAbPalmHotSync::nsAbPalmHotSync(PRBool aIsUnicode, PRUnichar * aAbDescUnicode, const char * aAbDesc, PRInt32 aPalmCatIndex, PRInt32 aPalmCatId)
{
mTotalCardCount=0;
mCardForPalmCount = 0;
mCardListForPalm = nsnull;
mInitialized = PR_FALSE;
mDBOpen = PR_FALSE;
if(aIsUnicode)
mAbName.Assign(aAbDescUnicode);
else
mAbName.AssignASCII(aAbDesc);
mAbName.Trim(" ");
mPalmCategoryIndex = aPalmCatIndex;
mPalmCategoryId = aPalmCatId;
mIsPalmDataUnicode = aIsUnicode;
mNewCardCount = 0;
NS_NewISupportsArray(getter_AddRefs(mNewCardsArray));
mIsNewCardForPalm = PR_FALSE;
}
// nsPKCS12Blob::LoadCerts
//
// Given an array of certificate nicknames, load the corresponding
// certificates into a local array.
nsresult
nsPKCS12Blob::LoadCerts(const PRUnichar **certNames, int numCerts)
{
nsresult rv;
char namecpy[256];
/* Create the local array if needed */
if (!mCertArray) {
rv = NS_NewISupportsArray(getter_AddRefs(mCertArray));
if (NS_FAILED(rv)) {
if (!handleError())
return NS_ERROR_OUT_OF_MEMORY;
}
}
/* Add the certs */
for (int i=0; i<numCerts; i++) {
strcpy(namecpy, NS_ConvertUTF16toUTF8(certNames[i]));
CERTCertificate *nssCert = PK11_FindCertFromNickname(namecpy, NULL);
if (!nssCert) {
if (!handleError())
return NS_ERROR_FAILURE;
else continue; /* user may request to keep going */
}
nsCOMPtr<nsIX509Cert> cert = nsNSSCertificate::Create(nssCert);
CERT_DestroyCertificate(nssCert);
if (!cert) {
if (!handleError())
return NS_ERROR_OUT_OF_MEMORY;
} else {
mCertArray->AppendElement(cert);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsHTTPIndex::ArcLabelsOut(nsIRDFResource *aSource, nsISimpleEnumerator **_retval)
{
nsresult rv = NS_ERROR_UNEXPECTED;
*_retval = nsnull;
nsCOMPtr<nsISupportsArray> array;
rv = NS_NewISupportsArray(getter_AddRefs(array));
if (NS_FAILED(rv)) return rv;
if (isWellknownContainerURI(aSource))
{
array->AppendElement(kNC_Child);
}
if (mInner)
{
nsCOMPtr<nsISimpleEnumerator> anonArcs;
rv = mInner->ArcLabelsOut(aSource, getter_AddRefs(anonArcs));
PRBool hasResults = PR_TRUE;
while (NS_SUCCEEDED(rv) &&
NS_SUCCEEDED(anonArcs->HasMoreElements(&hasResults)) &&
hasResults == PR_TRUE)
{
nsCOMPtr<nsISupports> anonArc;
if (NS_FAILED(anonArcs->GetNext(getter_AddRefs(anonArc))))
break;
array->AppendElement(anonArc);
}
}
return NS_NewArrayEnumerator(_retval, array);
}
nsresult
nsMsgAccountManagerDataSource::getAccountRootArcs(nsISupportsArray **aResult)
{
nsresult rv;
if (!mAccountRootArcsOut) {
rv = NS_NewISupportsArray(getter_AddRefs(mAccountRootArcsOut));
NS_ENSURE_SUCCESS(rv, rv);
mAccountRootArcsOut->AppendElement(kNC_Server);
mAccountRootArcsOut->AppendElement(kNC_Child);
mAccountRootArcsOut->AppendElement(kNC_Settings);
mAccountRootArcsOut->AppendElement(kNC_Name);
mAccountRootArcsOut->AppendElement(kNC_FolderTreeName);
mAccountRootArcsOut->AppendElement(kNC_FolderTreeSimpleName);
mAccountRootArcsOut->AppendElement(kNC_NameSort);
mAccountRootArcsOut->AppendElement(kNC_FolderTreeNameSort);
mAccountRootArcsOut->AppendElement(kNC_PageTag);
}
*aResult = mAccountRootArcsOut;
NS_IF_ADDREF(*aResult);
return NS_OK;
}
nsresult
nsHTTPIndex::AddElement(nsIRDFResource *parent, nsIRDFResource *prop, nsIRDFNode *child)
{
nsresult rv;
if (!mNodeList)
{
rv = NS_NewISupportsArray(getter_AddRefs(mNodeList));
if (NS_FAILED(rv)) return(rv);
}
// order required: parent, prop, then child
mNodeList->AppendElement(parent);
mNodeList->AppendElement(prop);
mNodeList->AppendElement(child);
if (!mTimer)
{
mTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create a timer");
if (NS_FAILED(rv)) return(rv);
mTimer->InitWithFuncCallback(nsHTTPIndex::FireTimer, this, 1,
nsITimer::TYPE_ONE_SHOT);
// Note: don't addref "this" as we'll cancel the
// timer in the httpIndex destructor
}
return(NS_OK);
}
/* nsIEnumerator listTokens (); */
NS_IMETHODIMP nsPK11TokenDB::ListTokens(nsIEnumerator* *_retval)
{
nsNSSShutDownPreventionLock locker;
nsCOMPtr<nsISupportsArray> array;
PK11SlotList *list = 0;
PK11SlotListElement *le;
*_retval = nullptr;
nsresult rv = NS_NewISupportsArray(getter_AddRefs(array));
if (NS_FAILED(rv)) { goto done; }
/* List all tokens, creating PK11Token objects and putting them
* into the array.
*/
list = PK11_GetAllTokens(CKM_INVALID_MECHANISM, false, false, 0);
if (!list) { rv = NS_ERROR_FAILURE; goto done; }
for (le = PK11_GetFirstSafe(list); le; le = PK11_GetNextSafe(list, le, false)) {
nsCOMPtr<nsIPK11Token> token = new nsPK11Token(le->slot);
rv = array->AppendElement(token);
if (NS_FAILED(rv)) {
PK11_FreeSlotListElement(list, le);
rv = NS_ERROR_OUT_OF_MEMORY;
goto done;
}
}
rv = array->Enumerate(_retval);
done:
if (list) PK11_FreeSlotList(list);
return rv;
}
//
// GetOutputDataFlavors
//
// Creates a new list and returns the list of all the flavors this converter
// knows how to export (convert). In this case, it's all sorts of things that HTML can be
// converted to.
//
// Flavors (strings) are wrapped in a primitive object so that JavaScript can
// access them easily via XPConnect.
//
NS_IMETHODIMP
nsHTMLFormatConverter::GetOutputDataFlavors(nsISupportsArray **_retval)
{
if ( !_retval )
return NS_ERROR_INVALID_ARG;
nsresult rv = NS_NewISupportsArray ( _retval ); // addrefs for us
if ( NS_SUCCEEDED(rv) ) {
rv = AddFlavorToList ( *_retval, kHTMLMime );
if ( NS_FAILED(rv) )
return rv;
#if NOT_NOW
// pinkerton
// no one uses this flavor right now, so it's just slowing things down. If anyone cares I
// can put it back in.
rv = AddFlavorToList ( *_retval, kAOLMailMime );
if ( NS_FAILED(rv) )
return rv;
#endif
rv = AddFlavorToList ( *_retval, kUnicodeMime );
if ( NS_FAILED(rv) )
return rv;
}
return rv;
} // GetOutputDataFlavors
/* nsIEnumerator listModules (); */
NS_IMETHODIMP
nsPKCS11ModuleDB::ListModules(nsIEnumerator **_retval)
{
nsNSSShutDownPreventionLock locker;
nsresult rv = NS_OK;
/* get isupports array */
nsCOMPtr<nsISupportsArray> array;
rv = NS_NewISupportsArray(getter_AddRefs(array));
if (NS_FAILED(rv)) return rv;
/* get the default list of modules */
SECMODModuleList *list = SECMOD_GetDefaultModuleList();
/* lock down the list for reading */
SECMODListLock *lock = SECMOD_GetDefaultModuleListLock();
SECMOD_GetReadLock(lock);
while (list) {
nsCOMPtr<nsIPKCS11Module> module = new nsPKCS11Module(list->module);
array->AppendElement(module);
list = list->next;
}
/* Get the modules in the database that didn't load */
list = SECMOD_GetDeadModuleList();
while (list) {
nsCOMPtr<nsIPKCS11Module> module = new nsPKCS11Module(list->module);
array->AppendElement(module);
list = list->next;
}
SECMOD_ReleaseReadLock(lock);
rv = array->Enumerate(_retval);
return rv;
}
/* nsIEnumerator listSlots (); */
NS_IMETHODIMP
nsPKCS11Module::ListSlots(nsIEnumerator **_retval)
{
nsNSSShutDownPreventionLock locker;
if (isAlreadyShutDown())
return NS_ERROR_NOT_AVAILABLE;
nsresult rv = NS_OK;
int i;
/* get isupports array */
nsCOMPtr<nsISupportsArray> array;
rv = NS_NewISupportsArray(getter_AddRefs(array));
if (NS_FAILED(rv)) return rv;
/* applications which allow new slot creation (which Firefox now does
* since it uses the WaitForSlotEvent call) need to hold the
* ModuleList Read lock to prevent the slot array from changing out
* from under it. */
SECMODListLock *lock = SECMOD_GetDefaultModuleListLock();
SECMOD_GetReadLock(lock);
for (i=0; i<mModule->slotCount; i++) {
if (mModule->slots[i]) {
nsCOMPtr<nsIPKCS11Slot> slot = new nsPKCS11Slot(mModule->slots[i]);
array->AppendElement(slot);
}
}
SECMOD_ReleaseReadLock(lock);
rv = array->Enumerate(_retval);
return rv;
}
/* void RegisterListener (in nsIWebProgressListener listener); */
NS_IMETHODIMP nsPrintProgress::RegisterListener(nsIWebProgressListener * listener)
{
nsresult rv = NS_OK;
if (!listener) //Nothing to do with a null listener!
return NS_OK;
if (!m_listenerList)
rv = NS_NewISupportsArray(getter_AddRefs(m_listenerList));
if (NS_SUCCEEDED(rv) && m_listenerList)
{
m_listenerList->AppendElement(listener);
if (m_closeProgress || m_processCanceled)
listener->OnStateChange(nsnull, nsnull, nsIWebProgressListener::STATE_STOP, 0);
else
{
listener->OnStatusChange(nsnull, nsnull, 0, m_pendingStatus.get());
if (m_pendingStateFlags != -1)
listener->OnStateChange(nsnull, nsnull, m_pendingStateFlags, m_pendingStateValue);
}
}
return NS_OK;
}
/* nsISimpleEnumerator GetTargets (in nsIRDFResource aSource, in nsIRDFResource property, in boolean aTruthValue); */
NS_IMETHODIMP
nsMsgAccountManagerDataSource::GetTargets(nsIRDFResource *source,
nsIRDFResource *property,
PRBool aTruthValue,
nsISimpleEnumerator **_retval)
{
nsresult rv = NS_RDF_NO_VALUE;
// create array and enumerator
// even if we're not handling this we need to return something empty?
nsCOMPtr<nsISupportsArray> nodes;
rv = NS_NewISupportsArray(getter_AddRefs(nodes));
if (NS_FAILED(rv)) return rv;
rv = NS_NewArrayEnumerator(_retval, nodes);
if (NS_FAILED(rv)) return rv;
if (source == kNC_AccountRoot)
rv = createRootResources(property, nodes);
else if (property == kNC_Settings)
rv = createSettingsResources(source, nodes);
if (NS_FAILED(rv))
return NS_RDF_NO_VALUE;
return NS_OK;
}
nsresult
nsDirectoryService::RealInit()
{
NS_ASSERTION(!gService,
"nsDirectoryService::RealInit Mustn't initialize twice!");
nsresult rv;
nsRefPtr<nsDirectoryService> self = new nsDirectoryService();
if (!self)
return NS_ERROR_OUT_OF_MEMORY;
rv = NS_NewISupportsArray(getter_AddRefs(((nsDirectoryService*) self)->mProviders));
if (NS_FAILED(rv))
return rv;
NS_RegisterStaticAtoms(directory_atoms, NS_ARRAY_LENGTH(directory_atoms));
// Let the list hold the only reference to the provider.
nsAppFileLocationProvider *defaultProvider = new nsAppFileLocationProvider;
if (!defaultProvider)
return NS_ERROR_OUT_OF_MEMORY;
// AppendElement returns PR_TRUE for success.
rv = ((nsDirectoryService*) self)->mProviders->AppendElement(defaultProvider) ? NS_OK : NS_ERROR_FAILURE;
if (NS_FAILED(rv))
return rv;
self.swap(gService);
return NS_OK;
}
NS_IMETHODIMP ImportOEAddressImpl::FindAddressBooks(nsIFile *location, nsISupportsArray **_retval)
{
NS_PRECONDITION(_retval != nsnull, "null ptr");
if (!_retval)
return NS_ERROR_NULL_POINTER;
nsresult rv = NS_NewISupportsArray(_retval);
if (NS_FAILED(rv))
return rv;
// Make sure we can load up the windows address book...
rv = NS_ERROR_FAILURE;
if (m_pWab)
delete m_pWab;
nsCOMPtr<nsIFile> currentProcessDir;
rv = NS_GetSpecialDirectory(NS_XPCOM_CURRENT_PROCESS_DIR,
getter_AddRefs(currentProcessDir));
bool equals = false;
currentProcessDir->Equals(location, &equals);
// If the location is not a fake, use it.
if (location && !equals) {
nsCOMPtr<nsIFile> localFile = do_QueryInterface(location, &rv);
NS_ENSURE_SUCCESS(rv, rv);
m_pWab = new CWAB(localFile);
} else {
m_pWab = new CWAB(nsnull);
}
nsIImportABDescriptor * pID;
nsISupports * pInterface;
nsString str;
str.Append(nsOEStringBundle::GetStringByID(OEIMPORT_DEFAULT_NAME));
if (m_pWab->Loaded()) {
// create a new nsIImportABDescriptor and add it to the array
nsCOMPtr<nsIImportService> impSvc(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
rv = impSvc->CreateNewABDescriptor(&pID);
if (NS_SUCCEEDED(rv)) {
pID->SetIdentifier(0x4F453334);
pID->SetRef(1);
pID->SetSize(100);
pID->SetPreferredName(str);
rv = pID->QueryInterface(kISupportsIID, (void **) &pInterface);
(*_retval)->AppendElement(pInterface);
pInterface->Release();
pID->Release();
}
}
}
if (NS_FAILED(rv)) {
delete m_pWab;
m_pWab = nsnull;
}
return NS_OK;
}
NS_IMETHODIMP
nsSeamonkeyProfileMigrator::GetSourceProfiles(nsISupportsArray** aResult)
{
if (!mProfileNames && !mProfileLocations) {
nsresult rv = NS_NewISupportsArray(getter_AddRefs(mProfileNames));
if (NS_FAILED(rv)) return rv;
rv = NS_NewISupportsArray(getter_AddRefs(mProfileLocations));
if (NS_FAILED(rv)) return rv;
// Fills mProfileNames and mProfileLocations
FillProfileDataFromSeamonkeyRegistry();
}
NS_IF_ADDREF(*aResult = mProfileNames);
return NS_OK;
}
nsMessengerUnixIntegration::nsMessengerUnixIntegration()
{
mBiffStateAtom = MsgGetAtom("BiffState");
mNewMailReceivedAtom = MsgGetAtom("NewMailReceived");
mAlertInProgress = false;
mLastMRUTimes.Init();
NS_NewISupportsArray(getter_AddRefs(mFoldersWithNewMail));
}
nsMessengerOSXIntegration::nsMessengerOSXIntegration()
{
mBiffStateAtom = do_GetAtom("BiffState");
mBiffIconVisible = PR_FALSE;
mSuppressBiffIcon = PR_FALSE;
mAlertInProgress = PR_FALSE;
NS_NewISupportsArray(getter_AddRefs(mFoldersWithNewMail));
}
NS_IMETHODIMP nsScrollPortView::AddScrollPositionListener(nsIScrollPositionListener* aListener)
{
if (nsnull == mListeners) {
nsresult rv = NS_NewISupportsArray(&mListeners);
if (NS_FAILED(rv))
return rv;
}
return mListeners->AppendElement(aListener);
}
NS_IMETHODIMP nsMessengerBootstrap::OpenMessengerWindowWithUri(const char *windowType, const char * aFolderURI, nsMsgKey aMessageKey)
{
bool standAloneMsgWindow = false;
nsCAutoString chromeUrl("chrome://messenger/content/");
if (windowType && !strcmp(windowType, "mail:messageWindow"))
{
chromeUrl.Append("messageWindow.xul");
standAloneMsgWindow = true;
}
nsCOMPtr<nsISupportsArray> argsArray;
nsresult rv = NS_NewISupportsArray(getter_AddRefs(argsArray));
NS_ENSURE_SUCCESS(rv, rv);
// create scriptable versions of our strings that we can store in our nsISupportsArray....
if (aFolderURI)
{
if (standAloneMsgWindow)
{
nsCOMPtr <nsIMsgFolder> folder;
rv = GetExistingFolder(nsDependentCString(aFolderURI), getter_AddRefs(folder));
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString msgUri;
folder->GetBaseMessageURI(msgUri);
nsCOMPtr<nsISupportsCString> scriptableMsgURI (do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID));
NS_ENSURE_TRUE(scriptableMsgURI, NS_ERROR_FAILURE);
msgUri.Append('#');
msgUri.AppendInt(aMessageKey, 10);
scriptableMsgURI->SetData(msgUri);
argsArray->AppendElement(scriptableMsgURI);
}
nsCOMPtr<nsISupportsCString> scriptableFolderURI (do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID));
NS_ENSURE_TRUE(scriptableFolderURI, NS_ERROR_FAILURE);
scriptableFolderURI->SetData(nsDependentCString(aFolderURI));
argsArray->AppendElement(scriptableFolderURI);
if (!standAloneMsgWindow)
{
nsCOMPtr<nsISupportsPRUint32> scriptableMessageKey (do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID));
NS_ENSURE_TRUE(scriptableMessageKey, NS_ERROR_FAILURE);
scriptableMessageKey->SetData(aMessageKey);
argsArray->AppendElement(scriptableMessageKey);
}
}
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
// we need to use the "mailnews.reuse_thread_window2" pref
// to determine if we should open a new window, or use an existing one.
nsCOMPtr<nsIDOMWindow> newWindow;
return wwatch->OpenWindow(0, chromeUrl.get(), "_blank",
"chrome,all,dialog=no", argsArray,
getter_AddRefs(newWindow));
}
nsMsgSearchSession::nsMsgSearchSession()
{
m_sortAttribute = nsMsgSearchAttrib::Sender;
m_idxRunningScope = 0;
m_urlQueueIndex = 0;
m_handlingError = PR_FALSE;
m_expressionTree = nsnull;
m_searchPaused = PR_FALSE;
NS_NewISupportsArray(getter_AddRefs(m_termList));
}
nsresult Do_CheckOneFile()
{
nsresult rv;
nsCOMPtr<nsITransferable> transferable;
nsCOMPtr<nsISupportsArray> transferableArray;
nsCOMPtr<nsISupports> genericWrapper;
nsRefPtr<IDataObject> dataObj;
rv = NS_NewISupportsArray(getter_AddRefs(transferableArray));
if (NS_FAILED(rv)) {
fail("Could not create the necessary nsISupportsArray");
return rv;
}
rv = GetTransferableFile(transferable);
if (NS_FAILED(rv)) {
fail("Could not create the proper nsITransferable!");
return rv;
}
genericWrapper = do_QueryInterface(transferable);
rv = transferableArray->AppendElement(genericWrapper);
if (NS_FAILED(rv)) {
fail("Could not append element to transferable array");
return rv;
}
rv = MakeDataObject(transferableArray, dataObj);
if (NS_FAILED(rv)) {
fail("Could not create data object");
return rv;
}
FORMATETC fe;
SET_FORMATETC(fe, CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL);
if (dataObj->QueryGetData(&fe) != S_OK) {
fail("File data object does not support the file data type!");
return NS_ERROR_UNEXPECTED;
}
STGMEDIUM* stg;
stg = (STGMEDIUM*)CoTaskMemAlloc(sizeof(STGMEDIUM));
if (dataObj->GetData(&fe, stg) != S_OK) {
fail("File data object did not provide data on request");
return NS_ERROR_UNEXPECTED;
}
rv = CheckValidHDROP(stg);
if (NS_FAILED(rv)) {
fail("HDROP was invalid");
return rv;
}
ReleaseStgMedium(stg);
return NS_OK;
}
/*
* set up the m_identities array
* do not call this more than once or we'll leak.
*/
nsresult
nsMsgAccount::createIdentities()
{
NS_ENSURE_TRUE(!m_accountKey.IsEmpty(), NS_ERROR_NOT_INITIALIZED);
if (m_identities)
return NS_ERROR_FAILURE;
NS_NewISupportsArray(getter_AddRefs(m_identities));
// get the pref
// ex) mail.account.myaccount.identities = "joe-home,joe-work"
nsCAutoString identitiesKeyPref("mail.account.");
identitiesKeyPref.Append(m_accountKey);
identitiesKeyPref.Append(".identities");
nsCString identityKey;
nsresult rv;
rv = getPrefService();
NS_ENSURE_SUCCESS(rv, rv);
m_prefs->GetCharPref(identitiesKeyPref.get(), getter_Copies(identityKey));
if (identityKey.IsEmpty()) // not an error if no identities, but
return NS_OK; // strtok will be unhappy
// get the server from the account manager
nsCOMPtr<nsIMsgAccountManager> accountManager =
do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
char* newStr = identityKey.BeginWriting();
char* token = NS_strtok(",", &newStr);
// temporaries used inside the loop
nsCOMPtr<nsIMsgIdentity> identity;
nsCAutoString key;
// iterate through id1,id2, etc
while (token) {
key = token;
key.StripWhitespace();
// create the account
rv = accountManager->GetIdentity(key, getter_AddRefs(identity));
if (NS_SUCCEEDED(rv)) {
// ignore error from addIdentityInternal() - if it fails, it fails.
rv = addIdentityInternal(identity);
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create identity");
}
// advance to next key, if any
token = NS_strtok(",", &newStr);
}
return rv;
}
NS_IMETHODIMP
nsSupportsArray::Clone(nsISupportsArray* *result)
{
nsresult rv;
nsISupportsArray* newArray;
rv = NS_NewISupportsArray(&newArray);
PRBool ok = EnumerateForwards(CopyElement, newArray);
if (!ok) return NS_ERROR_OUT_OF_MEMORY;
*result = newArray;
return NS_OK;
}
PRBool nsOEScanBoxes::GetMailboxList( nsIFile * root, nsISupportsArray **pArray)
{
nsresult rv = NS_NewISupportsArray( pArray);
if (NS_FAILED( rv)) {
IMPORT_LOG0( "FAILED to allocate the nsISupportsArray\n");
return( PR_FALSE);
}
BuildMailboxList( nsnull, root, 1, *pArray);
return( PR_TRUE);
}
NS_IMETHODIMP nsMsgMailNewsUrl:: CacheCacheEntry(nsICacheEntryDescriptor *cacheEntry)
{
if (!m_cachedMemCacheEntries)
NS_NewISupportsArray(getter_AddRefs(m_cachedMemCacheEntries));
if (m_cachedMemCacheEntries)
{
nsCOMPtr<nsISupports> cacheEntrySupports(do_QueryInterface(cacheEntry));
if(cacheEntrySupports)
m_cachedMemCacheEntries->AppendElement(cacheEntrySupports);
}
return NS_OK;
}
//
// GetInputDataFlavors
//
// Creates a new list and returns the list of all the flavors this converter
// knows how to import. In this case, it's just HTML.
//
// Flavors (strings) are wrapped in a primitive object so that JavaScript can
// access them easily via XPConnect.
//
NS_IMETHODIMP
nsHTMLFormatConverter::GetInputDataFlavors(nsISupportsArray **_retval)
{
if ( !_retval )
return NS_ERROR_INVALID_ARG;
nsresult rv = NS_NewISupportsArray ( _retval ); // addrefs for us
if ( NS_SUCCEEDED(rv) )
rv = AddFlavorToList ( *_retval, kHTMLMime );
return rv;
} // GetInputDataFlavors
NS_IMETHODIMP
nsSupportsArray::Clone(nsISupportsArray** aResult)
{
nsCOMPtr<nsISupportsArray> newArray;
nsresult rv = NS_NewISupportsArray(getter_AddRefs(newArray));
NS_ENSURE_SUCCESS(rv, rv);
bool ok = EnumerateForwards(CopyElement, newArray);
NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
newArray.forget(aResult);
return NS_OK;
}
// this is the method that initiates all searching for mailboxes.
// it will assume that it has a directory like ~/Library/Mail/
NS_IMETHODIMP nsAppleMailImportMail::FindMailboxes(nsIFile *aMailboxFile, nsISupportsArray **aResult)
{
NS_ENSURE_ARG_POINTER(aMailboxFile);
NS_ENSURE_ARG_POINTER(aResult);
IMPORT_LOG0("FindMailboxes for Apple mail invoked");
bool exists = false;
nsresult rv = aMailboxFile->Exists(&exists);
if (NS_FAILED(rv) || !exists)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIImportService> importService(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupportsArray> resultsArray;
NS_NewISupportsArray(getter_AddRefs(resultsArray));
if (!resultsArray)
return NS_ERROR_OUT_OF_MEMORY;
mCurDepth = 1;
// 1. look for accounts with mailboxes
FindAccountMailDirs(aMailboxFile, resultsArray, importService);
mCurDepth--;
if (NS_SUCCEEDED(rv)) {
// 2. look for "global" mailboxes, that don't belong to any specific account. they are inside the
// root's Mailboxes/ folder
nsCOMPtr<nsILocalFile> mailboxesDir(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsILocalFile> loc(do_QueryInterface(aMailboxFile, &rv));
if (NS_SUCCEEDED(rv)) {
mailboxesDir->InitWithFile(loc);
rv = mailboxesDir->Append(NS_LITERAL_STRING("Mailboxes"));
if (NS_SUCCEEDED(rv)) {
IMPORT_LOG0("Looking for global Apple mailboxes");
mCurDepth++;
rv = FindMboxDirs(mailboxesDir, resultsArray, importService);
mCurDepth--;
}
}
}
}
if (NS_SUCCEEDED(rv) && resultsArray)
resultsArray.swap(*aResult);
return rv;
}
nsresult
nsHTTPIndex::CommonInit()
{
nsresult rv = NS_OK;
// set initial/default encoding to ISO-8859-1 (not UTF-8)
mEncoding = "ISO-8859-1";
mDirRDF = do_GetService(kRDFServiceCID, &rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get RDF service");
if (NS_FAILED(rv)) {
return(rv);
}
mInner = do_CreateInstance("@mozilla.org/rdf/datasource;1?name=in-memory-datasource", &rv);
if (NS_FAILED(rv))
return rv;
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "child"),
getter_AddRefs(kNC_Child));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "loading"),
getter_AddRefs(kNC_Loading));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Comment"),
getter_AddRefs(kNC_Comment));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "URL"),
getter_AddRefs(kNC_URL));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Name"),
getter_AddRefs(kNC_Description));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Content-Length"),
getter_AddRefs(kNC_ContentLength));
mDirRDF->GetResource(NS_LITERAL_CSTRING(WEB_NAMESPACE_URI "LastModifiedDate"),
getter_AddRefs(kNC_LastModified));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Content-Type"),
getter_AddRefs(kNC_ContentType));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "File-Type"),
getter_AddRefs(kNC_FileType));
mDirRDF->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "IsContainer"),
getter_AddRefs(kNC_IsContainer));
rv = mDirRDF->GetLiteral(NS_LITERAL_STRING("true").get(), getter_AddRefs(kTrueLiteral));
if (NS_FAILED(rv)) return(rv);
rv = mDirRDF->GetLiteral(NS_LITERAL_STRING("false").get(), getter_AddRefs(kFalseLiteral));
if (NS_FAILED(rv)) return(rv);
rv = NS_NewISupportsArray(getter_AddRefs(mConnectionList));
if (NS_FAILED(rv)) return(rv);
// note: don't register DS here
return rv;
}
