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; }