NS_IMETHODIMP nsFilePicker::GetFiles(nsISimpleEnumerator **aFiles)
{
NS_ENSURE_ARG_POINTER(aFiles);
return NS_NewArrayEnumerator(aFiles, mFiles);
}
nsresult
nsXREDirProvider::GetFilesInternal(const char* aProperty,
nsISimpleEnumerator** aResult)
{
nsresult rv = NS_OK;
*aResult = nullptr;
if (!strcmp(aProperty, XRE_EXTENSIONS_DIR_LIST)) {
nsCOMArray<nsIFile> directories;
static const char *const kAppendNothing[] = { nullptr };
LoadDirsIntoArray(mAppBundleDirectories,
kAppendNothing, directories);
LoadDirsIntoArray(mExtensionDirectories,
kAppendNothing, directories);
rv = NS_NewArrayEnumerator(aResult, directories);
}
else if (!strcmp(aProperty, NS_APP_PREFS_DEFAULTS_DIR_LIST)) {
nsCOMArray<nsIFile> directories;
LoadDirIntoArray(mXULAppDir, kAppendPrefDir, directories);
LoadDirsIntoArray(mAppBundleDirectories,
kAppendPrefDir, directories);
rv = NS_NewArrayEnumerator(aResult, directories);
}
else if (!strcmp(aProperty, NS_EXT_PREFS_DEFAULTS_DIR_LIST)) {
nsCOMArray<nsIFile> directories;
LoadDirsIntoArray(mExtensionDirectories,
kAppendPrefDir, directories);
if (mProfileDir) {
nsCOMPtr<nsIFile> overrideFile;
mProfileDir->Clone(getter_AddRefs(overrideFile));
overrideFile->AppendNative(NS_LITERAL_CSTRING(PREF_OVERRIDE_DIRNAME));
bool exists;
if (NS_SUCCEEDED(overrideFile->Exists(&exists)) && exists)
directories.AppendObject(overrideFile);
}
rv = NS_NewArrayEnumerator(aResult, directories);
}
else if (!strcmp(aProperty, NS_APP_CHROME_DIR_LIST)) {
// NS_APP_CHROME_DIR_LIST is only used to get default (native) icons
// for OS window decoration.
static const char *const kAppendChromeDir[] = { "chrome", nullptr };
nsCOMArray<nsIFile> directories;
LoadDirIntoArray(mXULAppDir,
kAppendChromeDir,
directories);
LoadDirsIntoArray(mAppBundleDirectories,
kAppendChromeDir,
directories);
LoadDirsIntoArray(mExtensionDirectories,
kAppendChromeDir,
directories);
rv = NS_NewArrayEnumerator(aResult, directories);
}
else if (!strcmp(aProperty, NS_APP_PLUGINS_DIR_LIST)) {
nsCOMArray<nsIFile> directories;
if (mozilla::Preferences::GetBool("plugins.load_appdir_plugins", false)) {
nsCOMPtr<nsIFile> appdir;
rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(appdir));
if (NS_SUCCEEDED(rv)) {
appdir->SetNativeLeafName(NS_LITERAL_CSTRING("plugins"));
directories.AppendObject(appdir);
}
}
static const char *const kAppendPlugins[] = { "plugins", nullptr };
// The root dirserviceprovider does quite a bit for us: we're mainly
// interested in xulapp and extension-provided plugins.
LoadDirsIntoArray(mAppBundleDirectories,
kAppendPlugins,
directories);
LoadDirsIntoArray(mExtensionDirectories,
kAppendPlugins,
directories);
if (mProfileDir) {
nsCOMArray<nsIFile> profileDir;
profileDir.AppendObject(mProfileDir);
LoadDirsIntoArray(profileDir,
kAppendPlugins,
directories);
}
rv = NS_NewArrayEnumerator(aResult, directories);
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_SUCCESS_AGGREGATE_RESULT;
}
else
rv = NS_ERROR_FAILURE;
return rv;
}
NS_IMETHODIMP
nsStatusReporterManager::EnumerateReporters(nsISimpleEnumerator** result)
{
return NS_NewArrayEnumerator(result, mReporters);
}
NS_IMETHODIMP
DirectoryProvider::GetFiles(const char *aKey, nsISimpleEnumerator* *aResult)
{
/**
* We want to preserve the following order, since the search service loads
* engines in first-loaded-wins order.
* - distro search plugin locations (Loaded by the search service using
* NS_APP_DISTRIBUTION_SEARCH_DIR_LIST)
*
* - engines shipped in chrome (Loaded from jar files by the search
* service)
*
* Then other locations, from NS_APP_SEARCH_DIR_LIST:
* - extension search plugin locations (prepended below using
* NS_NewUnionEnumerator)
* - user search plugin locations (profile)
*/
nsresult rv;
if (!strcmp(aKey, NS_APP_DISTRIBUTION_SEARCH_DIR_LIST)) {
nsCOMPtr<nsIProperties> dirSvc
(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
if (!dirSvc)
return NS_ERROR_FAILURE;
nsCOMArray<nsIFile> distroFiles;
AppendDistroSearchDirs(dirSvc, distroFiles);
return NS_NewArrayEnumerator(aResult, distroFiles);
}
if (!strcmp(aKey, NS_APP_SEARCH_DIR_LIST)) {
nsCOMPtr<nsIProperties> dirSvc
(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
if (!dirSvc)
return NS_ERROR_FAILURE;
nsCOMArray<nsIFile> baseFiles;
AppendFileKey(NS_APP_USER_SEARCH_DIR, dirSvc, baseFiles);
nsCOMPtr<nsISimpleEnumerator> baseEnum;
rv = NS_NewArrayEnumerator(getter_AddRefs(baseEnum), baseFiles);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsISimpleEnumerator> list;
rv = dirSvc->Get(XRE_EXTENSIONS_DIR_LIST,
NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(list));
if (NS_FAILED(rv))
return rv;
static char const *const kAppendSPlugins[] = {"searchplugins", nullptr};
nsCOMPtr<nsISimpleEnumerator> extEnum =
new AppendingEnumerator(list, kAppendSPlugins);
if (!extEnum)
return NS_ERROR_OUT_OF_MEMORY;
return NS_NewUnionEnumerator(aResult, extEnum, baseEnum);
}
return NS_ERROR_FAILURE;
}
//-----------------------------------------------------------------------------
nsresult
CPlaylistCommandsManager::FindAllRootCommands(const nsAString &aContextGUID,
const nsAString &aContextType,
nsISimpleEnumerator **_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
nsresult rv;
nsString guid(aContextGUID);
nsString type(aContextType);
nsCOMArray<sbIPlaylistCommands> array;
nsCOMPtr<sbIPlaylistCommands> rootCommand;
// check if we got a guid to search for
if (!guid.IsEmpty())
{
// check if a root command exists in the medialist map for the guid
rv = GetPlaylistCommandsMediaList(guid,
SBVoidString(),
getter_AddRefs(rootCommand));
NS_ENSURE_SUCCESS(rv, rv);
if (rootCommand)
{
// if we find a root command, add it to the array and we'll return it
array.AppendObject(rootCommand);
}
// check if a root command exists in the mediaitem map for the guid
rv = GetPlaylistCommandsMediaItem(guid,
SBVoidString(),
getter_AddRefs(rootCommand));
NS_ENSURE_SUCCESS(rv, rv);
if (rootCommand)
{
// if we find a root command, add it to the array and we'll return it
array.AppendObject(rootCommand);
}
}
// check if we got a type to search for
if (!type.IsEmpty())
{
// check if a root command exists in the medialist map for the type
rv = GetPlaylistCommandsMediaList(SBVoidString(),
type,
getter_AddRefs(rootCommand));
NS_ENSURE_SUCCESS(rv, rv);
if (rootCommand)
{
// if we find a root command, add it to the array and we'll return it
array.AppendObject(rootCommand);
}
// check if a root command exists in the mediaitem map for the type
rv = GetPlaylistCommandsMediaItem(SBVoidString(),
type,
getter_AddRefs(rootCommand));
NS_ENSURE_SUCCESS(rv, rv);
if (rootCommand)
{
// if we find a root command, add it to the array and we'll return it
array.AppendObject(rootCommand);
}
}
return NS_NewArrayEnumerator(_retval, array);
}
NS_IMETHODIMP
nsArray::Enumerate(nsISimpleEnumerator **aResult)
{
return NS_NewArrayEnumerator(aResult, static_cast<nsIArray*>(this));
}
nsresult
nsMsgSendLater::InternalSendMessages(bool aUserInitiated,
nsIMsgIdentity *aIdentity)
{
if (WeAreOffline())
return NS_MSG_ERROR_OFFLINE;
// Protect against being called whilst we're already sending.
if (mSendingMessages)
{
NS_ERROR("nsMsgSendLater is already sending messages\n");
return NS_ERROR_FAILURE;
}
nsresult rv;
// XXX This code should be set up for multiple unsent folders, however we
// don't support that at the moment, so for now just assume one folder.
if (!mMessageFolder)
{
rv = GetUnsentMessagesFolder(nullptr,
getter_AddRefs(mMessageFolder));
NS_ENSURE_SUCCESS(rv, rv);
}
nsCOMPtr<nsIMsgDatabase> unsentDB;
// Remember these in case we need to reparse the db.
mUserInitiated = aUserInitiated;
mIdentity = aIdentity;
rv = ReparseDBIfNeeded(this);
NS_ENSURE_SUCCESS(rv, rv);
mIdentity = nullptr; // don't hold onto the identity since we're a service.
nsCOMPtr<nsISimpleEnumerator> enumerator;
rv = mMessageFolder->GetMessages(getter_AddRefs(enumerator));
NS_ENSURE_SUCCESS(rv, rv);
// copy all the elements in the enumerator into our isupports array....
nsCOMPtr<nsISupports> currentItem;
nsCOMPtr<nsIMsgDBHdr> messageHeader;
bool hasMoreElements = false;
while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) && hasMoreElements)
{
rv = enumerator->GetNext(getter_AddRefs(currentItem));
if (NS_SUCCEEDED(rv))
{
messageHeader = do_QueryInterface(currentItem, &rv);
if (NS_SUCCEEDED(rv))
{
if (aUserInitiated)
// If the user initiated the send, add all messages
mMessagesToSend.AppendObject(messageHeader);
else
{
// Else just send those that are NOT marked as Queued.
uint32_t flags;
rv = messageHeader->GetFlags(&flags);
if (NS_SUCCEEDED(rv) && !(flags & nsMsgMessageFlags::Queued))
mMessagesToSend.AppendObject(messageHeader);
}
}
}
}
// Now get an enumerator for our array.
rv = NS_NewArrayEnumerator(getter_AddRefs(mEnumerator), mMessagesToSend);
NS_ENSURE_SUCCESS(rv, rv);
// We're now sending messages so its time to signal that and reset our counts.
mSendingMessages = true;
mTotalSentSuccessfully = 0;
mTotalSendCount = 0;
// Notify the listeners that we are starting a send.
NotifyListenersOnStartSending(mMessagesToSend.Count());
return StartNextMailFileSend(NS_OK);
}