// caller must return from JNI immediately after calling this function
void JavaDOMGlobals::ThrowException(JNIEnv *env,
const char * message,
nsresult rv,
ExceptionType exceptionType) {
jthrowable newException = NULL;
if (exceptionType == EXCEPTION_DOM) {
PR_LOG(log, PR_LOG_ERROR,
("JavaDOMGlobals::ThrowException: (%x) %s: %s\n",
NS_ERROR_GET_CODE(rv),
message ? message : "",
DOM_EXCEPTION_MESSAGE[NS_ERROR_GET_CODE(rv)]));
jstring jmessage =
env->NewStringUTF(DOM_EXCEPTION_MESSAGE[NS_ERROR_GET_CODE(rv)]);
newException =
(jthrowable)env->NewObject(domExceptionClass,
domExceptionInitMID,
NS_ERROR_GET_CODE(rv),
jmessage);
} else {
char buffer[256];
const char* msg = message;
if (rv != NS_OK) {
sprintf(buffer,
"(%x.%x) %s",
NS_ERROR_GET_MODULE(rv),
NS_ERROR_GET_CODE(rv),
message ? message : "");
msg = buffer;
}
PR_LOG(log, PR_LOG_ERROR,
("JavaDOMGlobals::ThrowException: %s\n", msg));
jstring jmessage = env->NewStringUTF(msg);
newException =
(jthrowable)env->NewObject(runtimeExceptionClass,
runtimeExceptionInitMID,
jmessage);
}
if (newException != NULL) {
env->Throw(newException);
}
// an exception is thrown in any case
}
NS_IMETHODIMP
NSSErrorsService::GetErrorMessage(nsresult aXPCOMErrorCode, nsAString &aErrorMessage)
{
if (NS_ERROR_GET_MODULE(aXPCOMErrorCode) != NS_ERROR_MODULE_SECURITY ||
NS_ERROR_GET_SEVERITY(aXPCOMErrorCode) != NS_ERROR_SEVERITY_ERROR) {
return NS_ERROR_FAILURE;
}
int32_t aNSPRCode = -1 * NS_ERROR_GET_CODE(aXPCOMErrorCode);
if (!mozilla::psm::IsNSSErrorCode(aNSPRCode)) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIStringBundle> theBundle = mPIPNSSBundle;
const char *id_str = nsNSSErrors::getOverrideErrorStringName(aNSPRCode);
if (!id_str) {
id_str = nsNSSErrors::getDefaultErrorStringName(aNSPRCode);
theBundle = mNSSErrorsBundle;
}
if (!id_str || !theBundle) {
return NS_ERROR_FAILURE;
}
nsAutoString msg;
nsresult rv =
theBundle->GetStringFromName(NS_ConvertASCIItoUTF16(id_str).get(),
getter_Copies(msg));
if (NS_SUCCEEDED(rv)) {
aErrorMessage = msg;
}
return rv;
}
NS_IMETHODIMP
nsIDBDatabaseException::GetCode(PRUint16* aCode)
{
NS_ASSERTION(aCode, "Null pointer!");
nsresult result;
GetResult(&result);
*aCode = NS_ERROR_GET_CODE(result);
return NS_OK;
}
NS_IMETHODIMP
nsDOMFileException::GetCode(PRUint16* aCode)
{
NS_ENSURE_ARG_POINTER(aCode);
nsresult result;
GetResult(&result);
*aCode = NS_ERROR_GET_CODE(result);
return NS_OK;
}
nsresult
nsMsgDisplayMessageByID(nsIPrompt * aPrompt, PRInt32 msgID, const PRUnichar * windowTitle)
{
nsresult rv;
nsCOMPtr<nsIStringBundleService> bundleService(do_GetService("@mozilla.org/intl/stringbundle;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
nsString msg;
bundle->GetStringFromID(NS_IS_MSG_ERROR(msgID) ? NS_ERROR_GET_CODE(msgID) : msgID, getter_Copies(msg));
return nsMsgDisplayMessageByString(aPrompt, msg.get(), windowTitle);
}
PyObject *PyXPCOM_BuildErrorMessage(nsresult r)
{
char msg[512];
bool gotMsg = false;
if (!gotMsg)
{
nsresult rc;
nsCOMPtr <nsIExceptionService> es;
es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
if (NS_SUCCEEDED (rc))
{
nsCOMPtr <nsIExceptionManager> em;
rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
if (NS_SUCCEEDED (rc))
{
nsCOMPtr <nsIException> ex;
rc = em->GetExceptionFromProvider(r, NULL, getter_AddRefs (ex));
if (NS_SUCCEEDED (rc) && ex)
{
nsXPIDLCString emsg;
ex->GetMessage(getter_Copies(emsg));
PR_snprintf(msg, sizeof(msg), "%s",
emsg.get());
gotMsg = true;
}
}
}
}
if (!gotMsg)
{
const RTCOMERRMSG* pMsg = RTErrCOMGet(r);
if (strncmp(pMsg->pszMsgFull, "Unknown", 7) != 0)
{
PR_snprintf(msg, sizeof(msg), "%s (%s)",
pMsg->pszMsgFull, pMsg->pszDefine);
gotMsg = true;
}
}
if (!gotMsg)
{
PR_snprintf(msg, sizeof(msg), "Error 0x%x in module 0x%x",
NS_ERROR_GET_CODE(r), NS_ERROR_GET_MODULE(r));
}
PyObject *evalue = Py_BuildValue("is", r, msg);
return evalue;
}
nsresult
nsStringBundleService::FormatWithBundle(nsIStringBundle* bundle, nsresult aStatus,
PRUint32 argCount, PRUnichar** argArray,
PRUnichar* *result)
{
nsresult rv;
nsXPIDLCString key;
// then find a key into the string bundle for that particular error:
rv = mErrorService->GetErrorStringBundleKey(aStatus, getter_Copies(key));
// first try looking up the error message with the string key:
if (NS_SUCCEEDED(rv)) {
rv = bundle->FormatStringFromName(NS_ConvertASCIItoUTF16(key).get(),
(const PRUnichar**)argArray,
argCount, result);
}
// if the string key fails, try looking up the error message with the int key:
if (NS_FAILED(rv)) {
PRUint16 code = NS_ERROR_GET_CODE(aStatus);
rv = bundle->FormatStringFromID(code, (const PRUnichar**)argArray, argCount, result);
}
// If the int key fails, try looking up the default error message. E.g. print:
// An unknown error has occurred (0x804B0003).
if (NS_FAILED(rv)) {
nsAutoString statusStr; statusStr.AppendInt(aStatus, 16);
const PRUnichar* otherArgArray[1];
otherArgArray[0] = statusStr.get();
PRUint16 code = NS_ERROR_GET_CODE(NS_ERROR_FAILURE);
rv = bundle->FormatStringFromID(code, otherArgArray, 1, result);
}
return rv;
}
nsresult
nsMsgGetMessageByID(int32_t aMsgID, nsString& aResult)
{
nsresult rv;
nsCOMPtr<nsIStringBundleService> bundleService =
mozilla::services::GetStringBundleService();
NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
if (NS_IS_MSG_ERROR(aMsgID))
aMsgID = NS_ERROR_GET_CODE(aMsgID);
return bundle->GetStringFromID(aMsgID, getter_Copies(aResult));
}
NS_INTERFACE_MAP_END
NS_IMETHODIMP
nsComposeStringService::GetStringByID(PRInt32 aStringID, PRUnichar ** aString)
{
nsresult rv = NS_OK;
if (!mComposeStringBundle)
rv = InitializeStringBundle();
NS_ENSURE_TRUE(mComposeStringBundle, NS_ERROR_UNEXPECTED);
if (NS_IS_MSG_ERROR(aStringID))
aStringID = NS_ERROR_GET_CODE(aStringID);
NS_ENSURE_SUCCESS(mComposeStringBundle->GetStringFromID(aStringID, aString), NS_ERROR_UNEXPECTED);
return rv;
}
NS_IMETHODIMP
nsBaseDOMException::ToString(char **aReturn)
{
*aReturn = nsnull;
static const char defaultMsg[] = "<no message>";
static const char defaultLocation[] = "<unknown>";
static const char defaultName[] = "<unknown>";
static const char format[] =
"[Exception... \"%s\" code: \"%d\" nsresult: \"0x%x (%s)\" location: \"%s\"]";
nsCAutoString location;
if (mInner) {
nsXPIDLCString filename;
mInner->GetFilename(getter_Copies(filename));
if (!filename.IsEmpty()) {
PRUint32 line_nr = 0;
mInner->GetLineNumber(&line_nr);
char *temp = PR_smprintf("%s Line: %d", filename.get(), line_nr);
if (temp) {
location.Assign(temp);
PR_smprintf_free(temp);
}
}
}
if (location.IsEmpty()) {
location = defaultLocation;
}
const char* msg = mMessage ? mMessage : defaultMsg;
const char* resultName = mName ? mName : defaultName;
PRUint32 code = NS_ERROR_GET_CODE(mResult);
*aReturn = PR_smprintf(format, msg, code, mResult, resultName,
location.get());
return *aReturn ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
void
txStylesheetCompiler::cancel(nsresult aError, const PRUnichar *aErrorText,
const PRUnichar *aParam)
{
PR_LOG(txLog::xslt, PR_LOG_ALWAYS,
("Compiler::cancel: %s, module: %d, code %d\n",
NS_LossyConvertUTF16toASCII(mStylesheetURI).get(),
NS_ERROR_GET_MODULE(aError),
NS_ERROR_GET_CODE(aError)));
if (NS_SUCCEEDED(mStatus)) {
mStatus = aError;
}
if (mObserver) {
mObserver->onDoneCompiling(this, mStatus, aErrorText, aParam);
// This will ensure that we don't call onDoneCompiling twice. Also
// ensures that we don't keep the observer alive longer then necessary.
mObserver = nsnull;
}
}
nsresult
nsMsgBuildErrorMessageByID(PRInt32 msgID, nsString& retval, nsString* param0, nsString* param1)
{
nsresult rv;
nsCOMPtr<nsIStringBundleService> bundleService(do_GetService("@mozilla.org/intl/stringbundle;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
nsString msg;
rv = bundle->GetStringFromID(NS_IS_MSG_ERROR(msgID) ? NS_ERROR_GET_CODE(msgID) : msgID,
getter_Copies(retval));
NS_ENSURE_SUCCESS(rv, rv);
if (param0)
retval.ReplaceSubstring(NS_LITERAL_STRING("%P0%"), *param0);
if (param1)
retval.ReplaceSubstring(NS_LITERAL_STRING("%P1%"), *param1);
return rv;
}
NS_IMETHODIMP
nsAbLDAPAutoCompFormatter::FormatException(int32_t aState,
nsresult aErrorCode,
nsIAutoCompleteItem **aItem)
{
int32_t errorKey;
nsresult rv;
// create an nsIAutoCompleteItem to hold the returned value
//
nsCOMPtr<nsIAutoCompleteItem> item = do_CreateInstance(
NS_AUTOCOMPLETEITEM_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompFormatter::FormatException(): couldn't"
" create " NS_AUTOCOMPLETEITEM_CONTRACTID "\n");
return NS_ERROR_NOT_AVAILABLE;
}
// get the string bundle service
//
nsString errMsg, ldapErrMsg, alertMsg, ldapHint;
nsString errCodeNum;
nsCOMPtr<nsIStringBundleService> stringBundleSvc =
mozilla::services::GetStringBundleService();
if (stringBundleSvc) {
NS_ERROR("nsAbLDAPAutoCompleteFormatter::FormatException():"
" error getting string bundle service");
return NS_ERROR_UNEXPECTED;
}
// get the string bundles relevant here: the main LDAP bundle,
// and the ldap AutoCompletion-specific bundle
//
nsCOMPtr<nsIStringBundle> ldapBundle, ldapACBundle;
rv = stringBundleSvc->CreateBundle(
LDAP_ERROR_BUNDLE,
getter_AddRefs(ldapBundle));
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompleteFormatter::FormatException():"
" error creating string bundle "
LDAP_ERROR_BUNDLE);
return rv;
}
rv = stringBundleSvc->CreateBundle(
LDAP_AUTOCOMPLETE_ERROR_BUNDLE,
getter_AddRefs(ldapACBundle));
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompleteFormatter::FormatException():"
" error creating string bundle "
LDAP_AUTOCOMPLETE_ERROR_BUNDLE);
return rv;
}
// get the general error that goes in the dropdown and the window
// title
//
rv = ldapACBundle->GetStringFromID(aState, getter_Copies(errMsg));
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompleteFormatter::FormatException():"
" error getting general error from bundle "
LDAP_AUTOCOMPLETE_ERROR_BUNDLE);
return rv;
}
// for LDAP errors
//
if (NS_ERROR_GET_MODULE(aErrorCode) == NS_ERROR_MODULE_LDAP) {
errorKey = NS_ERROR_GET_CODE(aErrorCode);
// put the number itself in string form
//
errCodeNum.AppendInt(errorKey);
// get the LDAP error message itself
//
rv = ldapBundle->GetStringFromID(NS_ERROR_GET_CODE(aErrorCode),
getter_Copies(ldapErrMsg));
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompleteFormatter::FormatException"
"(): error getting string 2 from bundle "
LDAP_ERROR_BUNDLE);
return rv;
}
} else {
// put the entire nsresult in string form
//
errCodeNum.AppendLiteral("0x");
errCodeNum.AppendInt(aErrorCode, 16);
// figure out the key to index into the string bundle
//
const int32_t HOST_NOT_FOUND_ERROR=5000;
const int32_t GENERIC_ERROR=9999;
errorKey = ( (aErrorCode == NS_ERROR_UNKNOWN_HOST) ?
HOST_NOT_FOUND_ERROR : GENERIC_ERROR );
// get the specific error message itself
rv = ldapACBundle->GetStringFromID(errorKey,
getter_Copies(ldapErrMsg));
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompleteFormatter::FormatException"
"(): error getting specific non LDAP error-string "
"from bundle "
LDAP_AUTOCOMPLETE_ERROR_BUNDLE);
return rv;
}
}
// and try to find a hint about what the user should do next
//
const int32_t HINT_BASE=10000;
const int32_t GENERIC_HINT_CODE = 9999;
rv = ldapACBundle->GetStringFromID(HINT_BASE + errorKey,
getter_Copies(ldapHint));
if (NS_FAILED(rv)) {
rv = ldapACBundle->GetStringFromID(HINT_BASE + GENERIC_HINT_CODE,
getter_Copies(ldapHint));
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompleteFormatter::FormatException()"
"(): error getting hint string from bundle "
LDAP_AUTOCOMPLETE_ERROR_BUNDLE);
return rv;
}
}
const PRUnichar *stringParams[3] = { errCodeNum.get(),
ldapErrMsg.get(), ldapHint.get() };
rv = ldapACBundle->FormatStringFromName(
NS_LITERAL_STRING("errorAlertFormat").get(), stringParams, 3,
getter_Copies(alertMsg));
if (NS_FAILED(rv)) {
NS_WARNING("Failed to format warning string\n");
}
// put the error message, between angle brackets, into the XPIDL |value|
// attribute. Note that the hardcoded string is only used since
// stringbundles have already failed us.
//
if (errMsg.Length()) {
nsString tErrMsg(NS_LITERAL_STRING("<"));
tErrMsg.Append(errMsg);
tErrMsg.AppendLiteral(">");
rv = item->SetValue(tErrMsg);
} else {
rv = item->SetValue(
NS_LITERAL_STRING("<Unknown LDAP autocompletion error>"));
}
if (NS_FAILED(rv)) {
NS_ERROR("nsAbLDAPAutoCompFormatter::FormatException(): "
"item->SetValue failed");
return rv;
}
// pass the alert message in as the param; if that fails, proceed anyway
//
nsCOMPtr<nsISupportsString> alert(do_CreateInstance(
NS_SUPPORTS_STRING_CONTRACTID,
&rv));
if (NS_FAILED(rv)) {
NS_WARNING("nsAbLDAPAutoCompFormatter::FormatException(): "
"could not create nsISupportsString");
} else {
rv = alert->SetData(alertMsg);
if (NS_FAILED(rv)) {
NS_WARNING("nsAbLDAPAutoCompFormatter::FormatException(): "
"alert.Set() failed");
} else {
rv = item->SetParam(alert);
if (NS_FAILED(rv)) {
NS_WARNING("nsAbLDAPAutoCompFormatter::FormatException(): "
"item->SetParam failed");
}
}
}
// this is a remote addressbook, set the class name so the autocomplete
// item can be styled to show this
//
rv = item->SetClassName("remote-err");
if (NS_FAILED(rv)) {
NS_WARNING("nsAbLDAPAutoCompleteFormatter::FormatException():"
" item->SetClassName() failed");
}
// all done; return the item
//
NS_IF_ADDREF(*aItem = item);
return NS_OK;
}
/* nsresult displayReport (in nsIPrompt prompt, in boolean showErrorOnly, in boolean dontShowReportTwice); */
NS_IMETHODIMP nsMsgSendReport::DisplayReport(nsIPrompt *prompt, bool showErrorOnly, bool dontShowReportTwice, nsresult *_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
nsresult currError = NS_OK;
mProcessReport[mCurrentProcess]->GetError(&currError);
*_retval = currError;
if (dontShowReportTwice && mAlreadyDisplayReport)
return NS_OK;
if (showErrorOnly && NS_SUCCEEDED(currError))
return NS_OK;
nsString currMessage;
mProcessReport[mCurrentProcess]->GetMessage(getter_Copies(currMessage));
nsresult rv; // don't step on currError.
nsCOMPtr<nsIStringBundleService> bundleService(do_GetService("@mozilla.org/intl/stringbundle;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
if (NS_FAILED(rv))
{
//TODO need to display a generic hardcoded message
mAlreadyDisplayReport = true;
return NS_OK;
}
nsString dialogTitle;
nsString dialogMessage;
if (NS_SUCCEEDED(currError))
{
//TODO display a success error message
return NS_OK;
}
//Do we have an explanation of the error? if no, try to build one...
if (currMessage.IsEmpty())
{
switch (currError)
{
case NS_BINDING_ABORTED:
case NS_ERROR_SEND_FAILED:
case NS_ERROR_SEND_FAILED_BUT_NNTP_OK:
case NS_MSG_FAILED_COPY_OPERATION:
case NS_MSG_UNABLE_TO_SEND_LATER:
case NS_MSG_UNABLE_TO_SAVE_DRAFT:
case NS_MSG_UNABLE_TO_SAVE_TEMPLATE:
//Ignore, don't need to repeat ourself.
break;
default:
nsMsgGetMessageByID(currError, currMessage);
break;
}
}
if (mDeliveryMode == nsIMsgCompDeliverMode::Now || mDeliveryMode == nsIMsgCompDeliverMode::SendUnsent)
{
// SMTP is taking care of it's own error message and will return NS_ERROR_BUT_DONT_SHOW_ALERT as error code.
// In that case, we must not show an alert ourself.
if (currError == NS_ERROR_BUT_DONT_SHOW_ALERT)
{
mAlreadyDisplayReport = true;
return NS_OK;
}
bundle->GetStringFromID(NS_MSG_SEND_ERROR_TITLE, getter_Copies(dialogTitle));
PRInt32 preStrId = NS_ERROR_SEND_FAILED;
bool askToGoBackToCompose = false;
switch (mCurrentProcess)
{
case process_BuildMessage :
preStrId = NS_ERROR_SEND_FAILED;
askToGoBackToCompose = false;
break;
case process_NNTP :
preStrId = NS_ERROR_SEND_FAILED;
askToGoBackToCompose = false;
break;
case process_SMTP :
bool nntpProceeded;
mProcessReport[process_NNTP]->GetProceeded(&nntpProceeded);
if (nntpProceeded)
preStrId = NS_ERROR_SEND_FAILED_BUT_NNTP_OK;
else
preStrId = NS_ERROR_SEND_FAILED;
askToGoBackToCompose = false;
break;
case process_Copy:
preStrId = NS_MSG_FAILED_COPY_OPERATION;
askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
break;
case process_FCC:
preStrId = NS_MSG_FAILED_COPY_OPERATION;
askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
break;
}
bundle->GetStringFromID(preStrId, getter_Copies(dialogMessage));
//Do we already have an error message?
if (!askToGoBackToCompose && currMessage.IsEmpty())
{
//we don't have an error description but we can put a generic explanation
bundle->GetStringFromID(NS_MSG_GENERIC_FAILURE_EXPLANATION, getter_Copies(currMessage));
}
if (!currMessage.IsEmpty())
{
//Don't need to repeat ourself!
if (!currMessage.Equals(dialogMessage))
{
if (!dialogMessage.IsEmpty())
dialogMessage.Append(PRUnichar('\n'));
dialogMessage.Append(currMessage);
}
}
if (askToGoBackToCompose)
{
bool oopsGiveMeBackTheComposeWindow = true;
nsString text1;
bundle->GetStringFromID(NS_MSG_ASK_TO_COMEBACK_TO_COMPOSE, getter_Copies(text1));
if (!dialogMessage.IsEmpty())
dialogMessage.AppendLiteral("\n");
dialogMessage.Append(text1);
nsMsgAskBooleanQuestionByString(prompt, dialogMessage.get(), &oopsGiveMeBackTheComposeWindow, dialogTitle.get());
if (!oopsGiveMeBackTheComposeWindow)
*_retval = NS_OK;
}
else
nsMsgDisplayMessageByString(prompt, dialogMessage.get(), dialogTitle.get());
}
else
{
PRInt32 titleID;
PRInt32 preStrId;
switch (mDeliveryMode)
{
case nsIMsgCompDeliverMode::Later:
titleID = NS_MSG_SENDLATER_ERROR_TITLE;
preStrId = NS_MSG_UNABLE_TO_SEND_LATER;
break;
case nsIMsgCompDeliverMode::AutoSaveAsDraft:
case nsIMsgCompDeliverMode::SaveAsDraft:
titleID = NS_MSG_SAVE_DRAFT_TITLE;
preStrId = NS_MSG_UNABLE_TO_SAVE_DRAFT;
break;
case nsIMsgCompDeliverMode::SaveAsTemplate:
titleID = NS_MSG_SAVE_TEMPLATE_TITLE;
preStrId = NS_MSG_UNABLE_TO_SAVE_TEMPLATE;
break;
default:
/* This should never happend! */
titleID = NS_MSG_SEND_ERROR_TITLE;
preStrId = NS_ERROR_SEND_FAILED;
break;
}
bundle->GetStringFromID(titleID, getter_Copies(dialogTitle));
// preStrId could be a string ID or it could be an error code...yuck.
bundle->GetStringFromID(NS_IS_MSG_ERROR(preStrId) ? NS_ERROR_GET_CODE(preStrId) : preStrId, getter_Copies(dialogMessage));
//Do we have an error message...
if (currMessage.IsEmpty())
{
//we don't have an error description but we can put a generic explanation
bundle->GetStringFromID(NS_MSG_GENERIC_FAILURE_EXPLANATION, getter_Copies(currMessage));
}
if (!currMessage.IsEmpty())
{
if (!dialogMessage.IsEmpty())
dialogMessage.Append(PRUnichar('\n'));
dialogMessage.Append(currMessage);
}
nsMsgDisplayMessageByString(prompt, dialogMessage.get(), dialogTitle.get());
}
mAlreadyDisplayReport = true;
return NS_OK;
}
NS_IMETHODIMP nsMsgMdnGenerator::OnStopRunningUrl(nsIURI *url,
nsresult aExitCode)
{
nsresult rv;
DEBUG_MDN("nsMsgMdnGenerator::OnStopRunningUrl");
if (m_file)
m_file->Remove(PR_FALSE);
if (NS_SUCCEEDED(aExitCode))
return NS_OK;
switch (aExitCode)
{
case NS_ERROR_UNKNOWN_HOST:
case NS_ERROR_UNKNOWN_PROXY_HOST:
aExitCode = NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER;
break;
case NS_ERROR_CONNECTION_REFUSED:
case NS_ERROR_PROXY_CONNECTION_REFUSED:
aExitCode = NS_ERROR_SMTP_SEND_FAILED_REFUSED;
break;
case NS_ERROR_NET_INTERRUPT:
aExitCode = NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED;
break;
case NS_ERROR_NET_TIMEOUT:
case NS_ERROR_NET_RESET:
aExitCode = NS_ERROR_SMTP_SEND_FAILED_TIMEOUT;
break;
case NS_ERROR_SMTP_PASSWORD_UNDEFINED:
// nothing to do, just keep the code
break;
default:
if (aExitCode != NS_ERROR_ABORT && !NS_IS_MSG_ERROR(aExitCode))
aExitCode = NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON;
break;
}
nsCOMPtr<nsISmtpService> smtpService(do_GetService(NS_SMTPSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv,rv);
// Get the smtp hostname and format the string.
nsCString smtpHostName;
nsCOMPtr<nsISmtpServer> smtpServer;
rv = smtpService->GetSmtpServerByIdentity(m_identity, getter_AddRefs(smtpServer));
if (NS_SUCCEEDED(rv))
smtpServer->GetHostname(smtpHostName);
nsAutoString hostStr;
CopyASCIItoUTF16(smtpHostName, hostStr);
const PRUnichar *params[] = { hostStr.get() };
nsCOMPtr<nsIStringBundle> bundle;
nsCOMPtr<nsIStringBundleService> bundleService(do_GetService("@mozilla.org/intl/stringbundle;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
nsString failed_msg, dialogTitle;
bundle->FormatStringFromID(NS_ERROR_GET_CODE(aExitCode), params, 1, getter_Copies(failed_msg));
bundle->GetStringFromID(NS_MSG_SEND_ERROR_TITLE, getter_Copies(dialogTitle));
nsCOMPtr<nsIPrompt> dialog;
rv = m_window->GetPromptDialog(getter_AddRefs(dialog));
if (NS_SUCCEEDED(rv))
dialog->Alert(dialogTitle.get(),failed_msg.get());
return NS_OK;
}
nsresult
IDBRequest::SetDone(AsyncConnectionHelper* aHelper)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!mHaveResultOrErrorCode, "Already called!");
NS_ASSERTION(!mResultValRooted, "Already rooted?!");
NS_ASSERTION(JSVAL_IS_VOID(mResultVal), "Should be undefined!");
// See if our window is still valid. If not then we're going to pretend that
// we never completed.
if (NS_FAILED(CheckInnerWindowCorrectness())) {
return NS_OK;
}
mHaveResultOrErrorCode = true;
nsresult rv = aHelper->GetResultCode();
// If the request failed then set the error code and return.
if (NS_FAILED(rv)) {
mErrorCode = NS_ERROR_GET_CODE(rv);
return NS_OK;
}
// Otherwise we need to get the result from the helper.
JSContext* cx = static_cast<JSContext*>(mScriptContext->GetNativeContext());
NS_ASSERTION(cx, "Failed to get a context!");
JSObject* global = static_cast<JSObject*>(mScriptContext->GetNativeGlobal());
NS_ASSERTION(global, "Failed to get global object!");
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, global)) {
rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
else {
RootResultVal();
rv = aHelper->GetSuccessResult(cx, &mResultVal);
if (NS_SUCCEEDED(rv)) {
// Unroot if we don't really need to be rooted.
if (!JSVAL_IS_GCTHING(mResultVal)) {
UnrootResultVal();
}
}
else {
NS_WARNING("GetSuccessResult failed!");
}
}
if (NS_SUCCEEDED(rv)) {
mErrorCode = 0;
}
else {
mErrorCode = NS_ERROR_GET_CODE(rv);
mResultVal = JSVAL_VOID;
}
return rv;
}
