Bug 1380906 - Update Thunderbird for nsIStringBundle changes in bug 1380227. r=jorgk
authorNicholas Nethercote <nnethercote@mozilla.com>
Fri, 14 Jul 2017 12:55:40 +1000
changeset 28444 9faaede6aff6823a8a9df248a4c275b3ac8c19c5
parent 28443 7be30a48e5cf2c7d70fadb1f348879c17806c5f5
child 28445 6b9b94ad31c9801780a8fabbf49434fbf53870a8
push id1986
push userclokep@gmail.com
push dateWed, 02 Aug 2017 14:43:31 +0000
treeherdercomm-beta@b51c9adf2c9e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjorgk
bugs1380906, 1380227
Bug 1380906 - Update Thunderbird for nsIStringBundle changes in bug 1380227. r=jorgk
mail/components/shell/nsMailGNOMEIntegration.cpp
mailnews/addrbook/src/nsAbCardProperty.cpp
mailnews/addrbook/src/nsAbLDAPChangeLogData.cpp
mailnews/addrbook/src/nsAbLDAPListenerBase.cpp
mailnews/addrbook/src/nsAbManager.cpp
mailnews/addrbook/src/nsAbView.cpp
mailnews/addrbook/src/nsAddbookProtocolHandler.cpp
mailnews/addrbook/src/nsAddrDatabase.cpp
mailnews/base/search/src/nsMsgFilter.cpp
mailnews/base/search/src/nsMsgFilterService.cpp
mailnews/base/src/nsMessenger.cpp
mailnews/base/src/nsMessengerOSXIntegration.mm
mailnews/base/src/nsMessengerUnixIntegration.cpp
mailnews/base/src/nsMessengerWinIntegration.cpp
mailnews/base/src/nsMsgAccountManager.cpp
mailnews/base/src/nsMsgAccountManagerDS.cpp
mailnews/base/src/nsMsgDBView.cpp
mailnews/base/src/nsMsgFolderCompactor.cpp
mailnews/base/src/nsMsgFolderDataSource.cpp
mailnews/base/src/nsMsgOfflineManager.cpp
mailnews/base/src/nsMsgPrintEngine.cpp
mailnews/base/src/nsMsgStatusFeedback.cpp
mailnews/base/src/nsSpamSettings.cpp
mailnews/base/util/nsMsgDBFolder.cpp
mailnews/base/util/nsMsgIncomingServer.cpp
mailnews/base/util/nsMsgProtocol.cpp
mailnews/base/util/nsMsgUtils.cpp
mailnews/compose/src/nsComposeStrings.cpp
mailnews/compose/src/nsComposeStrings.h
mailnews/compose/src/nsMsgAttachmentHandler.cpp
mailnews/compose/src/nsMsgCompUtils.cpp
mailnews/compose/src/nsMsgCompose.cpp
mailnews/compose/src/nsMsgPrompts.cpp
mailnews/compose/src/nsMsgPrompts.h
mailnews/compose/src/nsMsgSend.cpp
mailnews/compose/src/nsMsgSend.h
mailnews/compose/src/nsMsgSendLater.cpp
mailnews/compose/src/nsMsgSendReport.cpp
mailnews/compose/src/nsSmtpProtocol.cpp
mailnews/compose/src/nsSmtpProtocol.h
mailnews/extensions/mailviews/src/nsMsgMailViewList.cpp
mailnews/extensions/mdn/src/nsMsgMdnGenerator.cpp
mailnews/extensions/mdn/src/nsMsgMdnGenerator.h
mailnews/extensions/smime/src/nsMsgComposeSecure.cpp
mailnews/extensions/smime/src/nsMsgComposeSecure.h
mailnews/imap/src/nsImapIncomingServer.cpp
mailnews/imap/src/nsImapMailFolder.cpp
mailnews/imap/src/nsImapProtocol.cpp
mailnews/imap/src/nsImapProtocol.h
mailnews/imap/src/nsImapService.cpp
mailnews/imap/src/nsImapStringBundle.cpp
mailnews/import/applemail/src/nsAppleMailImport.cpp
mailnews/import/becky/src/nsBeckyMail.cpp
mailnews/import/becky/src/nsBeckyStringBundle.cpp
mailnews/import/becky/src/nsBeckyStringBundle.h
mailnews/import/src/nsImportMail.cpp
mailnews/import/src/nsImportStringBundle.cpp
mailnews/intl/nsCharsetConverterManager.cpp
mailnews/local/src/nsLocalMailFolder.cpp
mailnews/local/src/nsMovemailService.cpp
mailnews/local/src/nsParseMailbox.cpp
mailnews/local/src/nsPop3Protocol.cpp
mailnews/local/src/nsPop3Protocol.h
mailnews/local/src/nsPop3Service.cpp
mailnews/local/src/nsPop3Sink.cpp
mailnews/mapi/mapihook/src/msgMapiHook.cpp
mailnews/mime/cthandlers/pgpmime/nsPgpMimeProxy.cpp
mailnews/mime/emitters/nsMimeBaseEmitter.cpp
mailnews/mime/emitters/nsMimeHtmlEmitter.cpp
mailnews/mime/src/mimemoz2.cpp
mailnews/news/src/nsNNTPNewsgroupList.cpp
mailnews/news/src/nsNNTPProtocol.cpp
mailnews/news/src/nsNewsDownloader.cpp
mailnews/news/src/nsNewsFolder.cpp
mailnews/news/src/nsNntpIncomingServer.cpp
suite/shell/src/nsGNOMEShellService.cpp
suite/shell/src/nsWindowsShellService.cpp
--- a/mail/components/shell/nsMailGNOMEIntegration.cpp
+++ b/mail/components/shell/nsMailGNOMEIntegration.cpp
@@ -304,17 +304,17 @@ nsMailGNOMEIntegration::MakeDefault(cons
       mozilla::services::GetStringBundleService();
     NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
 
     nsCOMPtr<nsIStringBundle> brandBundle;
     rv = bundleService->CreateBundle(BRAND_PROPERTIES, getter_AddRefs(brandBundle));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsString brandShortName;
-    brandBundle->GetStringFromName(u"brandShortName",
+    brandBundle->GetStringFromName("brandShortName",
                                    getter_Copies(brandShortName));
 
     // use brandShortName as the application id.
     NS_ConvertUTF16toUTF8 id(brandShortName);
 
     nsCOMPtr<nsIGIOMimeApp> app;
     rv = giovfs->CreateAppFromCommand(mAppPath, id, getter_AddRefs(app));
     NS_ENSURE_SUCCESS(rv, rv);
--- a/mailnews/addrbook/src/nsAbCardProperty.cpp
+++ b/mailnews/addrbook/src/nsAbCardProperty.cpp
@@ -728,17 +728,17 @@ nsresult nsAbCardProperty::ConvertToBase
   // Get Address Book string and set it as title of XML document
   nsCOMPtr<nsIStringBundle> bundle;
   nsCOMPtr<nsIStringBundleService> stringBundleService =
     mozilla::services::GetStringBundleService();
   if (stringBundleService) {
     rv = stringBundleService->CreateBundle(sAddrbookProperties, getter_AddRefs(bundle));
     if (NS_SUCCEEDED(rv)) {
       nsString addrBook;
-      rv = bundle->GetStringFromName(u"addressBook", getter_Copies(addrBook));
+      rv = bundle->GetStringFromName("addressBook", getter_Copies(addrBook));
       if (NS_SUCCEEDED(rv)) {
         xmlStr.AppendLiteral("<title xmlns=\"http://www.w3.org/1999/xhtml\">");
         xmlStr.Append(addrBook);
         xmlStr.AppendLiteral("</title>\n");
       }
     }
   }
 
@@ -820,17 +820,17 @@ nsresult nsAbCardProperty::ConvertToXMLP
   }
   else {
     rv = AppendSection(CUSTOM_ATTRS_ARRAY, sizeof(CUSTOM_ATTRS_ARRAY)/sizeof(AppendItem), NS_LITERAL_STRING("headingDescription"),
          bundle, conv, xmlStr);
 
     xmlStr.AppendLiteral("<section><sectiontitle>");
 
     nsString headingAddresses;
-    rv = bundle->GetStringFromName(u"headingAddresses", getter_Copies(headingAddresses));
+    rv = bundle->GetStringFromName("headingAddresses", getter_Copies(headingAddresses));
     NS_ENSURE_SUCCESS(rv, rv);
 
     xmlStr.Append(headingAddresses);
     xmlStr.AppendLiteral("</sectiontitle>");
 
     nsCOMPtr<nsIAbManager> abManager = do_GetService(NS_ABMANAGER_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
 
@@ -908,17 +908,17 @@ nsresult nsAbCardProperty::AppendSection
   for (i=0;i<aCount;i++) {
     rv = GetPropertyAsAString(aArray[i].mColumn, attrValue);
     if (NS_SUCCEEDED(rv) && !attrValue.IsEmpty())
       sectionIsEmpty = false;
   }
 
   if (!sectionIsEmpty && !aHeading.IsEmpty()) {
     nsString heading;
-    rv = aBundle->GetStringFromName(aHeading.get(), getter_Copies(heading));
+    rv = aBundle->GetStringFromName(NS_ConvertUTF16toUTF8(aHeading).get(), getter_Copies(heading));
     NS_ENSURE_SUCCESS(rv, rv);
 
     aResult.AppendLiteral("<sectiontitle>");
     aResult.Append(heading);
     aResult.AppendLiteral("</sectiontitle>");
   }
 
   for (i=0;i<aCount;i++) {
@@ -986,17 +986,17 @@ nsresult nsAbCardProperty::AppendLabel(c
   nsresult rv;
   nsString label, attrValue;
 
   rv = GetPropertyAsAString(aItem.mColumn, attrValue);
 
   if (NS_FAILED(rv) || attrValue.IsEmpty())
     return NS_OK;
 
-  rv = aBundle->GetStringFromName(NS_ConvertUTF8toUTF16(aItem.mLabel).get(), getter_Copies(label));
+  rv = aBundle->GetStringFromName(aItem.mLabel, getter_Copies(label));
   NS_ENSURE_SUCCESS(rv, rv);
 
   aResult.AppendLiteral("<labelrow><label>");
 
   aResult.Append(label);
   aResult.AppendLiteral(": </label>");
 
   rv = AppendLine(aItem, aConv, aResult);
@@ -1043,28 +1043,28 @@ nsresult nsAbCardProperty::AppendCitySta
 
   rv = AppendLine(item, aConv, zipResult);
   NS_ENSURE_SUCCESS(rv,rv);
 
   nsString formattedString;
 
   if (!cityResult.IsEmpty() && !stateResult.IsEmpty() && !zipResult.IsEmpty()) {
     const char16_t *formatStrings[] = { cityResult.get(), stateResult.get(), zipResult.get() };
-    rv = aBundle->FormatStringFromName(u"cityAndStateAndZip", formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
+    rv = aBundle->FormatStringFromName("cityAndStateAndZip", formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
     NS_ENSURE_SUCCESS(rv,rv);
   }
   else if (!cityResult.IsEmpty() && !stateResult.IsEmpty() && zipResult.IsEmpty()) {
     const char16_t *formatStrings[] = { cityResult.get(), stateResult.get() };
-    rv = aBundle->FormatStringFromName(u"cityAndStateNoZip", formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
+    rv = aBundle->FormatStringFromName("cityAndStateNoZip", formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
     NS_ENSURE_SUCCESS(rv,rv);
   }
   else if ((!cityResult.IsEmpty() && stateResult.IsEmpty() && !zipResult.IsEmpty()) ||
           (cityResult.IsEmpty() && !stateResult.IsEmpty() && !zipResult.IsEmpty())) {
     const char16_t *formatStrings[] = { cityResult.IsEmpty() ? stateResult.get() : cityResult.get(), zipResult.get() };
-    rv = aBundle->FormatStringFromName(u"cityOrStateAndZip", formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
+    rv = aBundle->FormatStringFromName("cityOrStateAndZip", formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
     NS_ENSURE_SUCCESS(rv,rv);
   }
   else {
     if (!cityResult.IsEmpty())
       formattedString = cityResult;
     else if (!stateResult.IsEmpty())
       formattedString = stateResult;
     else
@@ -1108,23 +1108,23 @@ NS_IMETHODIMP nsAbCardProperty::Generate
       NS_ENSURE_SUCCESS(rv, rv);
     }
 
     nsString result;
 
     if (aGenerateFormat == GENERATE_LAST_FIRST_ORDER) {
       const char16_t *stringParams[2] = {lastName.get(), firstName.get()};
 
-      rv = bundle->FormatStringFromName(u"lastFirstFormat",
+      rv = bundle->FormatStringFromName("lastFirstFormat",
                                         stringParams, 2, getter_Copies(result));
     }
     else {
       const char16_t *stringParams[2] = {firstName.get(), lastName.get()};
 
-      rv = bundle->FormatStringFromName(u"firstLastFormat",
+      rv = bundle->FormatStringFromName("firstLastFormat",
                                         stringParams, 2, getter_Copies(result));
     }
     NS_ENSURE_SUCCESS(rv, rv); 
 
     aResult.Assign(result);
   }
 
   if (aResult.IsEmpty())
--- a/mailnews/addrbook/src/nsAbLDAPChangeLogData.cpp
+++ b/mailnews/addrbook/src/nsAbLDAPChangeLogData.cpp
@@ -256,22 +256,22 @@ nsresult nsAbLDAPProcessChangeLogData::G
       mozilla::services::GetStringBundleService();
     NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
     nsCOMPtr<nsIStringBundle> bundle;
     rv = bundleService->CreateBundle("chrome://messenger/locale/addressbook/addressBook.properties", getter_AddRefs(bundle));
     if (NS_FAILED (rv)) 
         return rv ;
 
     nsString title;
-    rv = bundle->GetStringFromName(u"AuthDlgTitle", getter_Copies(title));
+    rv = bundle->GetStringFromName("AuthDlgTitle", getter_Copies(title));
     if (NS_FAILED (rv)) 
         return rv ;
 
     nsString desc;
-    rv = bundle->GetStringFromName(u"AuthDlgDesc", getter_Copies(desc));
+    rv = bundle->GetStringFromName("AuthDlgDesc", getter_Copies(desc));
     if (NS_FAILED (rv)) 
         return rv ;
 
     nsString username;
     nsString password;
     bool btnResult = false;
 	rv = dialog->PromptUsernameAndPassword(title, desc, 
                                             NS_ConvertUTF8toUTF16(serverUri).get(), 
--- a/mailnews/addrbook/src/nsAbLDAPListenerBase.cpp
+++ b/mailnews/addrbook/src/nsAbLDAPListenerBase.cpp
@@ -95,17 +95,17 @@ NS_IMETHODIMP nsAbLDAPListenerBase::OnLD
                "bundle chrome://mozldap/locale/ldap.properties");
       InitFailed();
       return rv;
     }
 
     // get the title for the authentication prompt
     //
     nsString authPromptTitle;
-    rv = ldapBundle->GetStringFromName(u"authPromptTitle",
+    rv = ldapBundle->GetStringFromName("authPromptTitle",
                                        getter_Copies(authPromptTitle));
     if (NS_FAILED(rv))
     {
       NS_ERROR("nsAbLDAPListenerBase::OnLDAPInit(): error getting"
                "'authPromptTitle' string from bundle "
                "chrome://mozldap/locale/ldap.properties");
       InitFailed();
       return rv;
@@ -128,17 +128,17 @@ NS_IMETHODIMP nsAbLDAPListenerBase::OnLD
     // which is the default compiler for Mozilla on linux at the moment.
     //
     NS_ConvertASCIItoUTF16 hostTemp(host);
     const char16_t *hostArray[1] = { hostTemp.get() };
 
     // format the hostname into the authprompt text string
     //
     nsString authPromptText;
-    rv = ldapBundle->FormatStringFromName(u"authPromptText",
+    rv = ldapBundle->FormatStringFromName("authPromptText",
                                           hostArray,
                                           sizeof(hostArray) / sizeof(const char16_t *),
                                           getter_Copies(authPromptText));
     if (NS_FAILED(rv))
     {
       NS_ERROR("nsAbLDAPListenerBase::OnLDAPInit():"
                "error getting 'authPromptText' string from bundle "
                "chrome://mozldap/locale/ldap.properties");
--- a/mailnews/addrbook/src/nsAbManager.cpp
+++ b/mailnews/addrbook/src/nsAbManager.cpp
@@ -539,53 +539,53 @@ NS_IMETHODIMP nsAbManager::ExportAddress
   rv = bundleService->CreateBundle("chrome://messenger/locale/addressbook/addressBook.properties", getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString dirName;
   aDirectory->GetDirName(dirName);
   const char16_t *formatStrings[] = { dirName.get() };
 
   nsString title;
-  rv = bundle->FormatStringFromName(u"ExportAddressBookNameTitle", formatStrings,
+  rv = bundle->FormatStringFromName("ExportAddressBookNameTitle", formatStrings,
                                     ArrayLength(formatStrings), getter_Copies(title));
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = filePicker->Init(aParentWin, title, nsIFilePicker::modeSave);
   NS_ENSURE_SUCCESS(rv, rv);
 
   filePicker->SetDefaultString(dirName);
 
   nsString filterString;
 
   // CSV: System charset and UTF-8.
-  rv = bundle->GetStringFromName(u"CSVFilesSysCharset", getter_Copies(filterString));
+  rv = bundle->GetStringFromName("CSVFilesSysCharset", getter_Copies(filterString));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = filePicker->AppendFilter(filterString, NS_LITERAL_STRING("*.csv"));
   NS_ENSURE_SUCCESS(rv, rv);
-  rv = bundle->GetStringFromName(u"CSVFilesUTF8", getter_Copies(filterString));
+  rv = bundle->GetStringFromName("CSVFilesUTF8", getter_Copies(filterString));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = filePicker->AppendFilter(filterString, NS_LITERAL_STRING("*.csv"));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Tab separated: System charset and UTF-8.
-  rv = bundle->GetStringFromName(u"TABFilesSysCharset", getter_Copies(filterString));
+  rv = bundle->GetStringFromName("TABFilesSysCharset", getter_Copies(filterString));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = filePicker->AppendFilter(filterString, NS_LITERAL_STRING("*.tab; *.txt"));
   NS_ENSURE_SUCCESS(rv, rv);
-  rv = bundle->GetStringFromName(u"TABFilesUTF8", getter_Copies(filterString));
+  rv = bundle->GetStringFromName("TABFilesUTF8", getter_Copies(filterString));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = filePicker->AppendFilter(filterString, NS_LITERAL_STRING("*.tab; *.txt"));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = bundle->GetStringFromName(u"VCFFiles", getter_Copies(filterString));
+  rv = bundle->GetStringFromName("VCFFiles", getter_Copies(filterString));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = filePicker->AppendFilter(filterString, NS_LITERAL_STRING("*.vcf"));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = bundle->GetStringFromName(u"LDIFFiles", getter_Copies(filterString));
+  rv = bundle->GetStringFromName("LDIFFiles", getter_Copies(filterString));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = filePicker->AppendFilter(filterString, NS_LITERAL_STRING("*.ldi; *.ldif"));
   NS_ENSURE_SUCCESS(rv, rv);
 
   int16_t dialogResult;
   filePicker->Show(&dialogResult);
 
   if (dialogResult == nsIFilePicker::returnCancel)
--- a/mailnews/addrbook/src/nsAbView.cpp
+++ b/mailnews/addrbook/src/nsAbView.cpp
@@ -1301,22 +1301,22 @@ NS_IMETHODIMP nsAbView::SwapFirstNameLas
 
           // Generate display name using the new order
           if (displayNameAutoGeneration &&
               !fn.IsEmpty() && !ln.IsEmpty())
           {
             nsString dnLnFn;
             nsString dnFnLn;
             const char16_t *nameString[2];
-            const char16_t *formatString;
+            const char *formatString;
 
             // The format should stays the same before/after we swap the names
             formatString = displayNameLastnamefirst ?
-                              u"lastFirstFormat" :
-                              u"firstLastFormat";
+                              "lastFirstFormat" :
+                              "firstLastFormat";
 
             // Generate both ln/fn and fn/ln combination since we need both later
             // to check to see if the current display name was edited
             // note that fn/ln still hold the values before the swap
             nameString[0] = ln.get();
             nameString[1] = fn.get();
             rv = bundle->FormatStringFromName(formatString,
                                               nameString, 2, getter_Copies(dnLnFn));
--- a/mailnews/addrbook/src/nsAddbookProtocolHandler.cpp
+++ b/mailnews/addrbook/src/nsAddbookProtocolHandler.cpp
@@ -282,17 +282,17 @@ nsAddbookProtocolHandler::BuildDirectory
   // Get Address Book string and set it as title of XML document
   nsCOMPtr<nsIStringBundle> bundle;
   nsCOMPtr<nsIStringBundleService> stringBundleService =
     mozilla::services::GetStringBundleService();
   if (stringBundleService) {
     rv = stringBundleService->CreateBundle("chrome://messenger/locale/addressbook/addressBook.properties", getter_AddRefs(bundle));
     if (NS_SUCCEEDED(rv)) {
       nsString addrBook;
-      rv = bundle->GetStringFromName(u"addressBook", getter_Copies(addrBook));
+      rv = bundle->GetStringFromName("addressBook", getter_Copies(addrBook));
       if (NS_SUCCEEDED(rv)) {
         aOutput.AppendLiteral("<title xmlns=\"http://www.w3.org/1999/xhtml\">");
         aOutput.Append(addrBook);
         aOutput.AppendLiteral("</title>\n");
       }
     }
   }
 
--- a/mailnews/addrbook/src/nsAddrDatabase.cpp
+++ b/mailnews/addrbook/src/nsAddrDatabase.cpp
@@ -406,22 +406,22 @@ nsresult nsAddrDatabase::DisplayAlert(co
     mozilla::services::GetStringBundleService();
   NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
 
   nsCOMPtr<nsIStringBundle> bundle;
   rv = bundleService->CreateBundle("chrome://messenger/locale/addressbook/addressBook.properties", getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString alertMessage;
-  rv = bundle->FormatStringFromName(alertStringName, formatStrings, numFormatStrings,
+  rv = bundle->FormatStringFromName(NS_ConvertUTF16toUTF8(alertStringName).get(), formatStrings, numFormatStrings,
     getter_Copies(alertMessage));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString alertTitle;
-  rv = bundle->GetStringFromName(titleName, getter_Copies(alertTitle));
+  rv = bundle->GetStringFromName(NS_ConvertUTF16toUTF8(titleName).get(), getter_Copies(alertTitle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIPromptService> prompter =
       do_GetService(NS_PROMPTSERVICE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return prompter->Alert(nullptr /* we don't know the parent window */, alertTitle.get(), alertMessage.get());
 }
--- a/mailnews/base/search/src/nsMsgFilter.cpp
+++ b/mailnews/base/search/src/nsMsgFilter.cpp
@@ -572,28 +572,28 @@ nsMsgFilter::LogRuleHitGeneric(nsIMsgRul
       PR_snprintf(tcode, sizeof(tcode), "0x%08x", aRcode);
 
       NS_ConvertASCIItoUTF16 tcode16(tcode) ;
       NS_ConvertASCIItoUTF16 tErrmsg16(aErrmsg) ;
 
       const char16_t *logErrorFormatStrings[2] = { tErrmsg16.get(),  tcode16.get()};
       nsString filterFailureWarningPrefix;
       rv = bundle->FormatStringFromName(
-                      u"filterFailureWarningPrefix",
+                      "filterFailureWarningPrefix",
                       logErrorFormatStrings, 2,
                       getter_Copies(filterFailureWarningPrefix));
       NS_ENSURE_SUCCESS(rv, rv);
       buffer += NS_ConvertUTF16toUTF8(filterFailureWarningPrefix);
       buffer += "\n";
     }
 
     const char16_t *filterLogDetectFormatStrings[4] = { filterName.get(), authorValue.get(), subjectValue.get(), dateValue.get() };
     nsString filterLogDetectStr;
     rv = bundle->FormatStringFromName(
-      u"filterLogDetectStr",
+      "filterLogDetectStr",
       filterLogDetectFormatStrings, 4,
       getter_Copies(filterLogDetectStr));
     NS_ENSURE_SUCCESS(rv, rv);
 
     buffer += NS_ConvertUTF16toUTF8(filterLogDetectStr);
     buffer +=  "\n";
 
     if (actionType == nsMsgFilterAction::MoveToFolder ||
@@ -606,41 +606,41 @@ nsMsgFilter::LogRuleHitGeneric(nsIMsgRul
       nsCString msgId;
       aMsgHdr->GetMessageId(getter_Copies(msgId));
       NS_ConvertASCIItoUTF16 msgIdValue(msgId);
 
       const char16_t *logMoveFormatStrings[2] = { msgIdValue.get(), actionFolderUriValue.get() };
       nsString logMoveStr;
       rv = bundle->FormatStringFromName(
         (actionType == nsMsgFilterAction::MoveToFolder) ?
-          u"logMoveStr" : u"logCopyStr",
+          "logMoveStr" : "logCopyStr",
         logMoveFormatStrings, 2,
         getter_Copies(logMoveStr));
       NS_ENSURE_SUCCESS(rv, rv);
 
       buffer += NS_ConvertUTF16toUTF8(logMoveStr);
     }
     else if (actionType == nsMsgFilterAction::Custom)
     {
       nsCOMPtr<nsIMsgFilterCustomAction> customAction;
       nsAutoString filterActionName;
       rv = aFilterAction->GetCustomAction(getter_AddRefs(customAction));
       if (NS_SUCCEEDED(rv) && customAction)
         customAction->GetName(filterActionName);
       if (filterActionName.IsEmpty())
         bundle->GetStringFromName(
-                  u"filterMissingCustomAction",
+                  "filterMissingCustomAction",
                   getter_Copies(filterActionName));
       buffer += NS_ConvertUTF16toUTF8(filterActionName);
     }
     else
     {
       nsString actionValue;
-      nsAutoString filterActionID;
-      filterActionID = NS_LITERAL_STRING("filterAction");
+      nsAutoCString filterActionID;
+      filterActionID = NS_LITERAL_CSTRING("filterAction");
       filterActionID.AppendInt(actionType);
       rv = bundle->GetStringFromName(filterActionID.get(), getter_Copies(actionValue));
       NS_ENSURE_SUCCESS(rv, rv);
 
       buffer += NS_ConvertUTF16toUTF8(actionValue);
     }
     buffer += "\n";
 
--- a/mailnews/base/search/src/nsMsgFilterService.cpp
+++ b/mailnews/base/search/src/nsMsgFilterService.cpp
@@ -211,17 +211,17 @@ nsresult nsMsgFilterService::AlertBackin
 nsresult //Do not use this routine if you have to call it very often because it creates a new bundle each time
 nsMsgFilterService::GetStringFromBundle(const char *aMsgName, char16_t **aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
 
   nsCOMPtr <nsIStringBundle> bundle;
   nsresult rv = GetFilterStringBundle(getter_AddRefs(bundle));
   if (NS_SUCCEEDED(rv) && bundle)
-    rv = bundle->GetStringFromName(NS_ConvertASCIItoUTF16(aMsgName).get(), aResult);
+    rv = bundle->GetStringFromName(aMsgName, aResult);
   return rv;
 
 }
 
 nsresult
 nsMsgFilterService::GetFilterStringBundle(nsIStringBundle **aBundle)
 {
   NS_ENSURE_ARG_POINTER(aBundle);
@@ -1176,17 +1176,17 @@ bool nsMsgFilterAfterTheFact::ContinueEx
   nsString filterName;
   m_curFilter->GetFilterName(filterName);
   nsString formatString;
   nsString confirmText;
   const char16_t *formatStrings[] =
   {
     filterName.get()
   };
-  nsresult rv = bundle->FormatStringFromName(u"continueFilterExecution",
+  nsresult rv = bundle->FormatStringFromName("continueFilterExecution",
                                              formatStrings, 1, getter_Copies(confirmText));
   if (NS_FAILED(rv))
     return false;
   bool returnVal = false;
   (void) DisplayConfirmationPrompt(m_msgWindow, confirmText.get(), &returnVal);
   return returnVal;
 }
 
--- a/mailnews/base/src/nsMessenger.cpp
+++ b/mailnews/base/src/nsMessenger.cpp
@@ -321,17 +321,17 @@ nsMessenger::PromptIfFileExists(nsIFile 
     file->GetPath(path);
     const char16_t *pathFormatStrings[] = { path.get() };
 
     if (!mStringBundle)
     {
       rv = InitStringBundle();
       NS_ENSURE_SUCCESS(rv, rv);
     }
-    rv = mStringBundle->FormatStringFromName(u"fileExists",
+    rv = mStringBundle->FormatStringFromName("fileExists",
                                              pathFormatStrings, 1,
                                              getter_Copies(errorMessage));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = dialog->Confirm(nullptr, errorMessage.get(), &dialogResult);
     NS_ENSURE_SUCCESS(rv, rv);
 
     if (dialogResult)
     {
@@ -839,17 +839,17 @@ nsMessenger::SaveOneAttachment(const cha
     {
       rv = InitStringBundle();
       NS_ENSURE_SUCCESS(rv, rv);
     }
 
     nsString filterName;
     const char16_t *extensionParam[] = { extension.get() };
     rv = mStringBundle->FormatStringFromName(
-      u"saveAsType", extensionParam, 1, getter_Copies(filterName));
+      "saveAsType", extensionParam, 1, getter_Copies(filterName));
     NS_ENSURE_SUCCESS(rv, rv);
 
     extension.Insert(NS_LITERAL_STRING("*."), 0);
     filePicker->AppendFilter(filterName, extension);
   }
 
   filePicker->AppendFilters(nsIFilePicker::filterAll);
 
@@ -2040,17 +2040,17 @@ nsMessenger::GetString(const nsString& a
 {
   nsresult rv;
   aValue.Truncate();
 
   if (!mStringBundle)
     rv = InitStringBundle();
 
   if (mStringBundle)
-    rv = mStringBundle->GetStringFromName(aStringName.get(), getter_Copies(aValue));
+    rv = mStringBundle->GetStringFromName(NS_ConvertUTF16toUTF8(aStringName).get(), getter_Copies(aValue));
   else
     rv = NS_ERROR_FAILURE;
 
   if (NS_FAILED(rv) || aValue.IsEmpty())
     aValue = aStringName;
   return;
 }
 
@@ -3065,18 +3065,18 @@ nsMessenger::PromptIfDeleteAttachments(b
     ConvertAndSanitizeFileName(aDisplayNameArray[u], displayString);
     attachmentList.Append(displayString);
     attachmentList.Append(char16_t('\n'));
   }
   const char16_t *formatStrings[] = { attachmentList.get() };
 
   // format the message and display
   nsString promptMessage;
-  const char16_t * propertyName = aSaveFirst ?
-    u"detachAttachments" : u"deleteAttachments";
+  const char * propertyName = aSaveFirst ?
+    "detachAttachments" : "deleteAttachments";
   rv = mStringBundle->FormatStringFromName(propertyName, formatStrings, 1,getter_Copies(promptMessage));
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool dialogResult = false;
   rv = dialog->Confirm(nullptr, promptMessage.get(), &dialogResult);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return dialogResult ? NS_OK : NS_ERROR_FAILURE;
--- a/mailnews/base/src/nsMessengerOSXIntegration.mm
+++ b/mailnews/base/src/nsMessengerOSXIntegration.mm
@@ -328,28 +328,28 @@ nsMessengerOSXIntegration::FillToolTipIn
       nsCString uri;
       aFolder->GetURI(uri);
 
       if (numNotDisplayed > 0)
       {
         nsAutoString numNotDisplayedText;
         numNotDisplayedText.AppendInt(numNotDisplayed);
         const char16_t *formatStrings[3] = { numNewMsgsText.get(), authors.get(), numNotDisplayedText.get() };
-        bundle->FormatStringFromName(u"macBiffNotification_messages_extra",
+        bundle->FormatStringFromName("macBiffNotification_messages_extra",
                                      formatStrings,
                                      3,
                                      getter_Copies(finalText));
       }
       else
       {
         const char16_t *formatStrings[2] = { numNewMsgsText.get(), authors.get() };
 
         if (aNewCount == 1)
         {
-          bundle->FormatStringFromName(u"macBiffNotification_message",
+          bundle->FormatStringFromName("macBiffNotification_message",
                                        formatStrings,
                                        2,
                                        getter_Copies(finalText));
           // Since there is only 1 message, use the most recent mail's URI instead of the folder's
           nsCOMPtr<nsIMsgDatabase> db;
           rv = aFolder->GetMsgDatabase(getter_AddRefs(db));
           if (NS_SUCCEEDED(rv) && db)
           {
@@ -363,17 +363,17 @@ nsMessengerOSXIntegration::FillToolTipIn
                                        getter_AddRefs(hdr));
               if (NS_SUCCEEDED(rv) && hdr)
                 aFolder->GetUriForMsg(hdr, uri);
             }
             NS_Free(newMessageKeys);
           }
         }
         else
-          bundle->FormatStringFromName(u"macBiffNotification_messages",
+          bundle->FormatStringFromName("macBiffNotification_messages",
                                        formatStrings,
                                        2,
                                        getter_Copies(finalText));
       }
       ShowAlertMessage(accountName, finalText, uri);
     } // if we got a bundle
   } // if we got a folder
 }
@@ -621,17 +621,17 @@ nsMessengerOSXIntegration::GetNewMailAut
     if (!bundle)
       return NS_ERROR_FAILURE;
 
     uint32_t *newMessageKeys;
     rv = db->GetNewList(&numNewKeys, &newMessageKeys);
     if (NS_SUCCEEDED(rv))
     {
       nsString listSeparator;
-      bundle->GetStringFromName(u"macBiffNotification_separator", getter_Copies(listSeparator));
+      bundle->GetStringFromName("macBiffNotification_separator", getter_Copies(listSeparator));
 
       int32_t displayed = 0;
       for (int32_t i = numNewKeys - 1; i >= 0; i--, aNewCount--)
       {
         if (0 == aNewCount || displayed == kMaxDisplayCount)
           break;
 
         nsCOMPtr<nsIMsgDBHdr> hdr;
--- a/mailnews/base/src/nsMessengerUnixIntegration.cpp
+++ b/mailnews/base/src/nsMessengerUnixIntegration.cpp
@@ -171,18 +171,18 @@ nsMessengerUnixIntegration::BuildNotific
   numNewMsgsText.AppendInt(numNewMessages);
 
   const char16_t *formatStrings[] =
   {
     accountName.get(), numNewMsgsText.get()
   };
 
   aBundle->FormatStringFromName(numNewMessages == 1 ?
-                                  u"newMailNotification_message" :
-                                  u"newMailNotification_messages",
+                                  "newMailNotification_message" :
+                                  "newMailNotification_messages",
                                 formatStrings, 2, getter_Copies(aTitle));
   return true;
 }
 
 /* This comparator lets us sort an nsCOMArray of nsIMsgDBHdr's by
  * their dateInSeconds attributes in ascending order.
  */
 static int
@@ -290,17 +290,17 @@ nsMessengerUnixIntegration::BuildNotific
 
   if (showSubject && showSender)
   {
     nsString msgTitle;
     const char16_t *formatStrings[] =
     {
       subject.get(), author.get()
     };
-    aBundle->FormatStringFromName(u"newMailNotification_messagetitle",
+    aBundle->FormatStringFromName("newMailNotification_messagetitle",
         formatStrings, 2, getter_Copies(msgTitle));
     alertBody.Append(msgTitle);
   }
   else if (showSubject)
     alertBody.Append(subject);
   else if (showSender)
     alertBody.Append(author);
 
--- a/mailnews/base/src/nsMessengerWinIntegration.cpp
+++ b/mailnews/base/src/nsMessengerWinIntegration.cpp
@@ -676,19 +676,19 @@ void nsMessengerWinIntegration::FillTool
 
         const char16_t *formatStrings[] =
         {
           numNewMsgsText.get(),
         };
 
         nsString finalText;
         if (numNewMessages == 1)
-          bundle->FormatStringFromName(u"biffNotification_message", formatStrings, 1, getter_Copies(finalText));
+          bundle->FormatStringFromName("biffNotification_message", formatStrings, 1, getter_Copies(finalText));
         else
-          bundle->FormatStringFromName(u"biffNotification_messages", formatStrings, 1, getter_Copies(finalText));
+          bundle->FormatStringFromName("biffNotification_messages", formatStrings, 1, getter_Copies(finalText));
 
         // the alert message is special...we actually only want to show the first account with
         // new mail in the alert.
         if (animatedAlertText.IsEmpty()) // if we haven't filled in the animated alert text yet
           animatedAlertText = finalText;
 
         toolTipLine.Append(accountName);
         toolTipLine.Append(' ');
--- a/mailnews/base/src/nsMsgAccountManager.cpp
+++ b/mailnews/base/src/nsMsgAccountManager.cpp
@@ -1280,17 +1280,17 @@ nsMsgAccountManager::LoadAccounts()
        * duplicate account. It checks that the server is not deferred to the
        * duplicate account. If it is, then it looks up the information for the
        * duplicate account's server (username, hostName, type), and finds an
        * account with a server with the same username, hostname, and type, and
        * if it finds one, defers to that account instead. Generally, this will
        * be a Local Folders account, since 2.0 has a bug where duplicate Local
        * Folders accounts are created.
        */
-      nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();    // njn: rename
+      nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
       nsCString type;
       server->GetType(type);
       if (type.EqualsLiteral("pop3"))
       {
         nsCString deferredToAccount;
         // Get the pref directly, because the GetDeferredToAccount accessor
         // attempts to fix broken deferrals, but we know more about what the
         // deferred to account was.
@@ -2295,17 +2295,17 @@ nsresult nsMsgAccountManager::GetLocalFo
   nsCOMPtr<nsIStringBundleService> sBundleService =
     mozilla::services::GetStringBundleService();
   NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
 
   rv = sBundleService->CreateBundle("chrome://messenger/locale/messenger.properties",
                                     getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  return bundle->GetStringFromName(u"localFolders", getter_Copies(localFoldersName));
+  return bundle->GetStringFromName("localFolders", getter_Copies(localFoldersName));
 }
 
 NS_IMETHODIMP
 nsMsgAccountManager::CreateLocalMailAccount()
 {
   // create the server
   nsCOMPtr<nsIMsgIncomingServer> server;
   nsresult rv = CreateIncomingServer(NS_LITERAL_CSTRING("nobody"),
--- a/mailnews/base/src/nsMsgAccountManagerDS.cpp
+++ b/mailnews/base/src/nsMsgAccountManagerDS.cpp
@@ -276,36 +276,36 @@ nsMsgAccountManagerDataSource::GetTarget
   if (property == kNC_Name || property == kNC_FolderTreeName ||
       property == kNC_FolderTreeSimpleName) 
   {
     rv = getStringBundle();
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsString pageTitle;
     if (source == kNC_PageTitleServer)
-      mStringBundle->GetStringFromName(u"prefPanel-server",
+      mStringBundle->GetStringFromName("prefPanel-server",
                                        getter_Copies(pageTitle));
 
     else if (source == kNC_PageTitleCopies)
-      mStringBundle->GetStringFromName(u"prefPanel-copies",
+      mStringBundle->GetStringFromName("prefPanel-copies",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleSynchronization)
-      mStringBundle->GetStringFromName(u"prefPanel-synchronization",
+      mStringBundle->GetStringFromName("prefPanel-synchronization",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleDiskSpace)
-      mStringBundle->GetStringFromName(u"prefPanel-diskspace",
+      mStringBundle->GetStringFromName("prefPanel-diskspace",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleAddressing)
-      mStringBundle->GetStringFromName(u"prefPanel-addressing",
+      mStringBundle->GetStringFromName("prefPanel-addressing",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleSMTP)
-      mStringBundle->GetStringFromName(u"prefPanel-smtp",
+      mStringBundle->GetStringFromName("prefPanel-smtp",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleJunk)
-      mStringBundle->GetStringFromName(u"prefPanel-junk",
+      mStringBundle->GetStringFromName("prefPanel-junk",
                                        getter_Copies(pageTitle));
 
     else {
       // if it's a server, use the pretty name
       nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(source, &rv);
       if (NS_SUCCEEDED(rv) && folder) {
         bool isServer;
         rv = folder->GetIsServer(&isServer);
@@ -341,19 +341,19 @@ nsMsgAccountManagerDataSource::GetTarget
         bundleURL += (sourceValue + strlen(NC_RDF_PAGETITLE_PREFIX));
         bundleURL += ".properties";
 
         nsCOMPtr <nsIStringBundle> bundle;
         rv = strBundleService->CreateBundle(bundleURL.get(), getter_AddRefs(bundle));
 
         NS_ENSURE_SUCCESS(rv,rv);
 
-        nsAutoString panelTitleName;
+        nsAutoCString panelTitleName;
         panelTitleName.AssignLiteral("prefPanel-");
-        panelTitleName.Append(NS_ConvertASCIItoUTF16(sourceValue + strlen(NC_RDF_PAGETITLE_PREFIX)));
+        panelTitleName.Append(sourceValue + strlen(NC_RDF_PAGETITLE_PREFIX));
         bundle->GetStringFromName(panelTitleName.get(), getter_Copies(pageTitle));
       }
     }
     str = pageTitle.get();
   }
   else if (property == kNC_PageTag) {
     // do NOT localize these strings. these are the urls of the XUL files
     if (source == kNC_PageTitleServer)
--- a/mailnews/base/src/nsMsgDBView.cpp
+++ b/mailnews/base/src/nsMsgDBView.cpp
@@ -218,17 +218,17 @@ char16_t * nsMsgDBView::GetString(const 
     static const char propertyURL[] = MESSENGER_STRING_URL;
     nsCOMPtr<nsIStringBundleService> sBundleService =
       mozilla::services::GetStringBundleService();
     if (sBundleService)
       res = sBundleService->CreateBundle(propertyURL, getter_AddRefs(mMessengerStringBundle));
   }
 
   if (mMessengerStringBundle)
-    res = mMessengerStringBundle->GetStringFromName(aStringName, &ptrv);
+    res = mMessengerStringBundle->GetStringFromName(NS_ConvertUTF16toUTF8(aStringName).get(), &ptrv);
 
   if ( NS_SUCCEEDED(res) && (ptrv) )
     return ptrv;
   else
     return NS_strdup(aStringName);
 }
 
 // helper function used to fetch localized strings from the prefs
--- a/mailnews/base/src/nsMsgFolderCompactor.cpp
+++ b/mailnews/base/src/nsMsgFolderCompactor.cpp
@@ -338,17 +338,17 @@ nsresult nsFolderCompactState::ShowStatu
     rv = server->GetPrettyName(accountName);
     if (NS_FAILED(rv))
       break;
     nsCOMPtr<nsIStringBundle> bundle;
     rv = GetBaseStringBundle(getter_AddRefs(bundle));
     if (NS_FAILED(rv))
       break;
     const char16_t *params[] = { accountName.get(), aMsg.get() };
-    rv = bundle->FormatStringFromName(u"statusMessage",
+    rv = bundle->FormatStringFromName("statusMessage",
                                       params, 2, getter_Copies(statusMessage));
   } while (false);
 
   // If fetching any of the needed info failed, just show the original message.
   if (NS_FAILED(rv))
     statusMessage.Assign(aMsg);
   return statusFeedback->SetStatusString(statusMessage);
 }
@@ -682,17 +682,17 @@ void nsFolderCompactState::ShowDoneStatu
   {
     nsString statusString;
     nsCOMPtr <nsIStringBundle> bundle;
     nsresult rv = GetBaseStringBundle(getter_AddRefs(bundle));
     NS_ENSURE_SUCCESS_VOID(rv);
     nsAutoString expungedAmount;
     FormatFileSize(m_totalExpungedBytes, true, expungedAmount);
     const char16_t* params[] = { expungedAmount.get() };
-    rv = bundle->FormatStringFromName(u"compactingDone",
+    rv = bundle->FormatStringFromName("compactingDone",
                                       params, 1, getter_Copies(statusString));
 
     if (!statusString.IsEmpty() && NS_SUCCEEDED(rv))
       ShowStatusMsg(statusString);
   }
 }
 
 nsresult
--- a/mailnews/base/src/nsMsgFolderDataSource.cpp
+++ b/mailnews/base/src/nsMsgFolderDataSource.cpp
@@ -1982,17 +1982,17 @@ nsresult nsMsgFolderDataSource::DoDelete
         NS_ENSURE_ARG_POINTER(msgWindow);
         nsCOMPtr<nsIStringBundleService> sBundleService =
           mozilla::services::GetStringBundleService();
         NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
         nsCOMPtr<nsIStringBundle> sMessengerStringBundle;
         nsString confirmMsg;
         rv = sBundleService->CreateBundle(MESSENGER_STRING_URL, getter_AddRefs(sMessengerStringBundle));
         NS_ENSURE_SUCCESS(rv, rv);
-        sMessengerStringBundle->GetStringFromName(u"confirmSavedSearchDeleteMessage", getter_Copies(confirmMsg));
+        sMessengerStringBundle->GetStringFromName("confirmSavedSearchDeleteMessage", getter_Copies(confirmMsg));
 
         nsCOMPtr<nsIPrompt> dialog;
         rv = msgWindow->GetPromptDialog(getter_AddRefs(dialog));
         if (NS_SUCCEEDED(rv))
         {
           bool dialogResult;
           rv = dialog->Confirm(nullptr, confirmMsg.get(), &dialogResult);
           if (!dialogResult)
--- a/mailnews/base/src/nsMsgOfflineManager.cpp
+++ b/mailnews/base/src/nsMsgOfflineManager.cpp
@@ -244,17 +244,17 @@ nsresult nsMsgOfflineManager::ShowStatus
     nsCOMPtr<nsIStringBundleService> sBundleService = 
       mozilla::services::GetStringBundleService();
     NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
     sBundleService->CreateBundle(MESSENGER_STRING_URL, getter_AddRefs(mStringBundle));
     return NS_OK;
   }
 
   nsString statusString;
-  nsresult res = mStringBundle->GetStringFromName(NS_ConvertASCIItoUTF16(statusMsgName).get(),
+  nsresult res = mStringBundle->GetStringFromName(statusMsgName,
 						  getter_Copies(statusString));
 
   if (NS_SUCCEEDED(res) && m_statusFeedback)
     m_statusFeedback->ShowStatusString(statusString);
 
   return res;
 }
 
--- a/mailnews/base/src/nsMsgPrintEngine.cpp
+++ b/mailnews/base/src/nsMsgPrintEngine.cpp
@@ -568,17 +568,17 @@ nsMsgPrintEngine::GetString(const char16
 
     nsCOMPtr<nsIStringBundleService> sBundleService = 
       mozilla::services::GetStringBundleService();
     if (sBundleService)
       sBundleService->CreateBundle(propertyURL, getter_AddRefs(mStringBundle));
   }
 
   if (mStringBundle)
-    mStringBundle->GetStringFromName(aStringName, getter_Copies(outStr));
+    mStringBundle->GetStringFromName(NS_ConvertUTF16toUTF8(aStringName).get(), getter_Copies(outStr));
   return;
 }
 
 //-----------------------------------------------------------
 void
 nsMsgPrintEngine::PrintMsgWindow()
 {
   const char* kMsgKeys[] = {"PrintingMessage",  "PrintPreviewMessage",
--- a/mailnews/base/src/nsMsgStatusFeedback.cpp
+++ b/mailnews/base/src/nsMsgStatusFeedback.cpp
@@ -82,17 +82,17 @@ nsMsgStatusFeedback::OnStateChange(nsIWe
   NS_ENSURE_TRUE(mBundle, NS_ERROR_NULL_POINTER);
   if (aProgressStateFlags & STATE_IS_NETWORK)
   {
     if (aProgressStateFlags & STATE_START)
     {
       m_lastPercent = 0;
       StartMeteors();
       nsString loadingDocument;
-      rv = mBundle->GetStringFromName(u"documentLoading",
+      rv = mBundle->GetStringFromName("documentLoading",
                                       getter_Copies(loadingDocument));
       if (NS_SUCCEEDED(rv))
         ShowStatusString(loadingDocument);
     }
     else if (aProgressStateFlags & STATE_STOP)
     {
       // if we are loading message for display purposes, this STATE_STOP notification is 
       // the only notification we get when layout is actually done rendering the message. We need
@@ -136,17 +136,17 @@ nsMsgStatusFeedback::OnStateChange(nsIWe
               if (msgFolder && msgHdr)
                 msgFolder->NotifyPropertyFlagChanged(msgHdr, m_msgLoadedAtom, 0, 1);
             }
           }
         }
       }
       StopMeteors();
       nsString documentDone;
-      rv = mBundle->GetStringFromName(u"documentDone",
+      rv = mBundle->GetStringFromName("documentDone",
                                       getter_Copies(documentDone));
       if (NS_SUCCEEDED(rv))
         ShowStatusString(documentDone);
     }
   }
   return NS_OK;
 }
 
@@ -286,17 +286,17 @@ NS_IMETHODIMP nsMsgStatusFeedback::OnSta
   nsString statusMessage;
   if (!str.IsEmpty() && str.Find(accountName) == kNotFound)
   {
     nsCOMPtr<nsIStringBundle> bundle;
     rv = sbs->CreateBundle(MSGS_URL, getter_AddRefs(bundle));
     const char16_t *params[] = { accountName.get(),
                                   str.get() };
     rv = bundle->FormatStringFromName(
-      u"statusMessage",
+      "statusMessage",
       params, 2, getter_Copies(statusMessage));
     NS_ENSURE_SUCCESS(rv, rv);
   }
   else
   {
     statusMessage.Assign(str);
   }
   return ShowStatusString(statusMessage);
--- a/mailnews/base/src/nsSpamSettings.cpp
+++ b/mailnews/base/src/nsSpamSettings.cpp
@@ -669,17 +669,17 @@ NS_IMETHODIMP nsSpamSettings::LogJunkHit
   nsCOMPtr<nsIStringBundle> bundle;
   rv = bundleService->CreateBundle("chrome://messenger/locale/filter.properties",
     getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   const char16_t *junkLogDetectFormatStrings[3] = { authorValue.get(), subjectValue.get(), dateValue.get() };
   nsString junkLogDetectStr;
   rv = bundle->FormatStringFromName(
-    u"junkLogDetectStr",
+    "junkLogDetectStr",
     junkLogDetectFormatStrings, 3,
     getter_Copies(junkLogDetectStr));
   NS_ENSURE_SUCCESS(rv, rv);
 
   buffer += NS_ConvertUTF16toUTF8(junkLogDetectStr);
   buffer +=  "\n";
 
   if (aMoveMessage) {
@@ -691,17 +691,17 @@ NS_IMETHODIMP nsSpamSettings::LogJunkHit
     NS_ENSURE_SUCCESS(rv, rv);
 
     NS_ConvertASCIItoUTF16 msgIdValue(msgId);
     NS_ConvertASCIItoUTF16 junkFolderURIValue(junkFolderURI);
 
     const char16_t *logMoveFormatStrings[2] = { msgIdValue.get(), junkFolderURIValue.get() };
     nsString logMoveStr;
     rv = bundle->FormatStringFromName(
-      u"logMoveStr",
+      "logMoveStr",
       logMoveFormatStrings, 2,
       getter_Copies(logMoveStr));
     NS_ENSURE_SUCCESS(rv, rv);
 
     buffer += NS_ConvertUTF16toUTF8(logMoveStr);
     buffer += "\n";
   }
 
--- a/mailnews/base/util/nsMsgDBFolder.cpp
+++ b/mailnews/base/util/nsMsgDBFolder.cpp
@@ -1916,25 +1916,25 @@ nsresult nsMsgDBFolder::HandleAutoCompac
           NS_ENSURE_SUCCESS(rv, rv);
           nsString dialogTitle;
           nsString confirmString;
           nsString checkboxText;
           nsString buttonCompactNowText;
           nsAutoString compactSize;
           FormatFileSize(totalExpungedBytes, true, compactSize);
           const char16_t* params[] = { compactSize.get() };
-          rv = bundle->GetStringFromName(u"autoCompactAllFoldersTitle", getter_Copies(dialogTitle));
+          rv = bundle->GetStringFromName("autoCompactAllFoldersTitle", getter_Copies(dialogTitle));
           NS_ENSURE_SUCCESS(rv, rv);
-          rv = bundle->FormatStringFromName(u"autoCompactAllFoldersText",
+          rv = bundle->FormatStringFromName("autoCompactAllFoldersText",
                                             params, 1, getter_Copies(confirmString));
           NS_ENSURE_SUCCESS(rv, rv);
-          rv = bundle->GetStringFromName(u"autoCompactAlwaysAskCheckbox",
+          rv = bundle->GetStringFromName("autoCompactAlwaysAskCheckbox",
                                          getter_Copies(checkboxText));
           NS_ENSURE_SUCCESS(rv, rv);
-          rv = bundle->GetStringFromName(u"compactNowButton",
+          rv = bundle->GetStringFromName("compactNowButton",
                                          getter_Copies(buttonCompactNowText));
           NS_ENSURE_SUCCESS(rv, rv);
           bool alwaysAsk = true; // "Always ask..." - checked by default.
           int32_t buttonPressed = 0;
 
           nsCOMPtr<nsIPrompt> dialog;
           rv = aWindow->GetPromptDialog(getter_AddRefs(dialog));
           NS_ENSURE_SUCCESS(rv, rv);
@@ -2920,37 +2920,37 @@ nsMsgDBFolder::initializeStrings()
   nsCOMPtr<nsIStringBundleService> bundleService =
     mozilla::services::GetStringBundleService();
   NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
   nsCOMPtr<nsIStringBundle> bundle;
   rv = bundleService->CreateBundle("chrome://messenger/locale/messenger.properties",
                                    getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  bundle->GetStringFromName(u"inboxFolderName",
+  bundle->GetStringFromName("inboxFolderName",
                             &kLocalizedInboxName);
-  bundle->GetStringFromName(u"trashFolderName",
+  bundle->GetStringFromName("trashFolderName",
                             &kLocalizedTrashName);
-  bundle->GetStringFromName(u"sentFolderName",
+  bundle->GetStringFromName("sentFolderName",
                             &kLocalizedSentName);
-  bundle->GetStringFromName(u"draftsFolderName",
+  bundle->GetStringFromName("draftsFolderName",
                             &kLocalizedDraftsName);
-  bundle->GetStringFromName(u"templatesFolderName",
+  bundle->GetStringFromName("templatesFolderName",
                             &kLocalizedTemplatesName);
-  bundle->GetStringFromName(u"junkFolderName",
+  bundle->GetStringFromName("junkFolderName",
                             &kLocalizedJunkName);
-  bundle->GetStringFromName(u"outboxFolderName",
+  bundle->GetStringFromName("outboxFolderName",
                             &kLocalizedUnsentName);
-  bundle->GetStringFromName(u"archivesFolderName",
+  bundle->GetStringFromName("archivesFolderName",
                             &kLocalizedArchivesName);
 
   nsCOMPtr<nsIStringBundle> brandBundle;
   rv = bundleService->CreateBundle("chrome://branding/locale/brand.properties", getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
-  bundle->GetStringFromName(u"brandShortName",
+  bundle->GetStringFromName("brandShortName",
                             &kLocalizedBrandShortName);
   return NS_OK;
 }
 
 nsresult
 nsMsgDBFolder::createCollationKeyGenerator()
 {
   nsresult rv = NS_OK;
@@ -3850,17 +3850,17 @@ nsMsgDBFolder::ConfirmAutoFolderRename(n
   const char16_t *formatStrings[] =
   {
     aOldName.get(),
     folderName.get(),
     aNewName.get()
   };
 
   nsString confirmString;
-  rv = bundle->FormatStringFromName(u"confirmDuplicateFolderRename",
+  rv = bundle->FormatStringFromName("confirmDuplicateFolderRename",
                                     formatStrings, 3, getter_Copies(confirmString));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return false;
   }
 
   bool confirmed = false;
   rv = ThrowConfirmationPrompt(msgWindow, confirmString, &confirmed);
   if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -5198,17 +5198,17 @@ nsMsgDBFolder::GetBaseStringBundle(nsISt
 
 nsresult //Do not use this routine if you have to call it very often because it creates a new bundle each time
 nsMsgDBFolder::GetStringFromBundle(const char *msgName, nsString& aResult)
 {
   nsresult rv;
   nsCOMPtr <nsIStringBundle> bundle;
   rv = GetBaseStringBundle(getter_AddRefs(bundle));
   if (NS_SUCCEEDED(rv) && bundle)
-    rv = bundle->GetStringFromName(NS_ConvertASCIItoUTF16(msgName).get(), getter_Copies(aResult));
+    rv = bundle->GetStringFromName(msgName, getter_Copies(aResult));
   return rv;
 }
 
 nsresult
 nsMsgDBFolder::ThrowConfirmationPrompt(nsIMsgWindow *msgWindow, const nsAString& confirmString, bool *confirmed)
 {
   if (msgWindow)
   {
@@ -5235,17 +5235,17 @@ nsMsgDBFolder::GetStringWithFolderNameFr
     GetName(folderName);
     const char16_t *formatStrings[] =
     {
       folderName.get(),
       kLocalizedBrandShortName
     };
 
     nsString resultStr;
-    rv = bundle->FormatStringFromName(NS_ConvertASCIItoUTF16(msgName).get(),
+    rv = bundle->FormatStringFromName(msgName,
                                       formatStrings, 2, getter_Copies(resultStr));
     if (NS_SUCCEEDED(rv))
       aResult.Assign(resultStr);
   }
   return rv;
 }
 
 NS_IMETHODIMP nsMsgDBFolder::ConfirmFolderDeletionForFilter(nsIMsgWindow *msgWindow, bool *confirmed)
--- a/mailnews/base/util/nsMsgIncomingServer.cpp
+++ b/mailnews/base/util/nsMsgIncomingServer.cpp
@@ -1637,18 +1637,18 @@ NS_IMETHODIMP nsMsgIncomingServer::Displ
 
   nsCOMPtr<nsIStringBundle> bundle;
   nsresult rv = bundleService->CreateBundle(BASE_MSGS_URL, getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
   if (bundle)
   {
     nsString errorMsgTitle;
     nsString errorMsgBody;
-    bundle->GetStringFromName(u"nocachedbodybody2", getter_Copies(errorMsgBody));
-    bundle->GetStringFromName(u"nocachedbodytitle", getter_Copies(errorMsgTitle));
+    bundle->GetStringFromName("nocachedbodybody2", getter_Copies(errorMsgBody));
+    bundle->GetStringFromName("nocachedbodytitle", getter_Copies(errorMsgTitle));
     aMsgWindow->DisplayHTMLInMessagePane(errorMsgTitle, errorMsgBody, true);
   }
 
   return NS_OK;
 }
 
 // Called only during the migration process. A unique name is generated for the
 // migrated account.
--- a/mailnews/base/util/nsMsgProtocol.cpp
+++ b/mailnews/base/util/nsMsgProtocol.cpp
@@ -1546,15 +1546,15 @@ char16_t *FormatStringWithHostNameByName
   NS_ENSURE_SUCCESS(rv, nullptr);
 
   nsCString hostName;
   rv = server->GetRealHostName(hostName);
   NS_ENSURE_SUCCESS(rv, nullptr);
 
   NS_ConvertASCIItoUTF16 hostStr(hostName);
   const char16_t *params[] = { hostStr.get() };
-  rv = sBundle->FormatStringFromName(stringName, params, 1, &ptrv);
+  rv = sBundle->FormatStringFromName(NS_ConvertUTF16toUTF8(stringName).get(), params, 1, &ptrv);
   NS_ENSURE_SUCCESS(rv, nullptr);
 
   return ptrv;
 }
 
 // vim: ts=2 sw=2
--- a/mailnews/base/util/nsMsgUtils.cpp
+++ b/mailnews/base/util/nsMsgUtils.cpp
@@ -473,23 +473,21 @@ nsresult NS_MsgHashIfNecessary(nsAutoStr
     name.Append(NS_ConvertASCIItoUTF16(hashedname));
   }
 
   return NS_OK;
 }
 
 nsresult FormatFileSize(int64_t size, bool useKB, nsAString &formattedSize)
 {
-  NS_NAMED_LITERAL_STRING(byteAbbr, "byteAbbreviation2");
-  NS_NAMED_LITERAL_STRING(kbAbbr,   "kiloByteAbbreviation2");
-  NS_NAMED_LITERAL_STRING(mbAbbr,   "megaByteAbbreviation2");
-  NS_NAMED_LITERAL_STRING(gbAbbr,   "gigaByteAbbreviation2");
-
-  const char16_t *sizeAbbrNames[] = {
-    byteAbbr.get(), kbAbbr.get(), mbAbbr.get(), gbAbbr.get()
+  const char *sizeAbbrNames[] = {
+    "byteAbbreviation2",
+    "kiloByteAbbreviation2",
+    "megaByteAbbreviation2",
+    "gigaByteAbbreviation2",
   };
 
   nsresult rv;
 
   nsCOMPtr<nsIStringBundleService> bundleSvc =
     mozilla::services::GetStringBundleService();
   NS_ENSURE_TRUE(bundleSvc, NS_ERROR_UNEXPECTED);
 
@@ -1760,43 +1758,43 @@ NS_MSG_BASE nsresult MsgPromptLoginFaile
                                getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString message;
   NS_ConvertUTF8toUTF16 hostNameUTF16(aHostname);
   NS_ConvertUTF8toUTF16 userNameUTF16(aUsername);
   const char16_t *formatStrings[] = { hostNameUTF16.get(), userNameUTF16.get() };
 
-  rv = bundle->FormatStringFromName(u"mailServerLoginFailed2",
+  rv = bundle->FormatStringFromName("mailServerLoginFailed2",
                                     formatStrings, 2,
                                     getter_Copies(message));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString title;
   if (aAccountname.IsEmpty()) {
     // Account name may be empty e.g. on a SMTP server.
     rv = bundle->GetStringFromName(
-      u"mailServerLoginFailedTitle", getter_Copies(title));
+      "mailServerLoginFailedTitle", getter_Copies(title));
   } else {
     const char16_t *formatStrings[] = { aAccountname.BeginReading() };
     rv = bundle->FormatStringFromName(
-      u"mailServerLoginFailedTitleWithAccount",
+      "mailServerLoginFailedTitleWithAccount",
       formatStrings, 1, getter_Copies(title));
   }
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString button0;
   rv = bundle->GetStringFromName(
-    u"mailServerLoginFailedRetryButton",
+    "mailServerLoginFailedRetryButton",
     getter_Copies(button0));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString button2;
   rv = bundle->GetStringFromName(
-    u"mailServerLoginFailedEnterNewPasswordButton",
+    "mailServerLoginFailedEnterNewPasswordButton",
     getter_Copies(button2));
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool dummyValue = false;
   return dialog->ConfirmEx(
     title.get(), message.get(),
     (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_0) +
     (nsIPrompt::BUTTON_TITLE_CANCEL * nsIPrompt::BUTTON_POS_1) +
--- a/mailnews/compose/src/nsComposeStrings.cpp
+++ b/mailnews/compose/src/nsComposeStrings.cpp
@@ -1,116 +1,116 @@
 /* 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 "nsComposeStrings.h"
 
-const char16_t* errorStringNameForErrorCode(nsresult aCode)
+const char* errorStringNameForErrorCode(nsresult aCode)
 {
 #ifdef __GNUC__
 // Temporary workaroung until bug 783526 is fixed.
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch"
 #endif
   switch(aCode)
   {
     case NS_MSG_UNABLE_TO_OPEN_FILE:
-      return u"unableToOpenFile";
+      return "unableToOpenFile";
     case NS_MSG_UNABLE_TO_OPEN_TMP_FILE:
-      return u"unableToOpenTmpFile";
+      return "unableToOpenTmpFile";
     case NS_MSG_UNABLE_TO_SAVE_TEMPLATE:
-      return u"unableToSaveTemplate";
+      return "unableToSaveTemplate";
     case NS_MSG_UNABLE_TO_SAVE_DRAFT:
-      return u"unableToSaveDraft";
+      return "unableToSaveDraft";
     case NS_MSG_COULDNT_OPEN_FCC_FOLDER:
-      return u"couldntOpenFccFolder";
+      return "couldntOpenFccFolder";
     case NS_MSG_NO_SENDER:
-      return u"noSender";
+      return "noSender";
     case NS_MSG_NO_RECIPIENTS:
-      return u"noRecipients";
+      return "noRecipients";
     case NS_MSG_ERROR_WRITING_FILE:
-      return u"errorWritingFile";
+      return "errorWritingFile";
     case NS_ERROR_SENDING_FROM_COMMAND:
-      return u"errorSendingFromCommand";
+      return "errorSendingFromCommand";
     case NS_ERROR_SENDING_DATA_COMMAND:
-      return u"errorSendingDataCommand";
+      return "errorSendingDataCommand";
     case NS_ERROR_SENDING_MESSAGE:
-      return u"errorSendingMessage";
+      return "errorSendingMessage";
     case NS_ERROR_POST_FAILED:
-      return u"postFailed";
+      return "postFailed";
     case NS_ERROR_QUEUED_DELIVERY_FAILED:
-      return u"errorQueuedDeliveryFailed";
+      return "errorQueuedDeliveryFailed";
     case NS_ERROR_SEND_FAILED:
-      return u"sendFailed";
+      return "sendFailed";
     case NS_ERROR_SMTP_SERVER_ERROR:
-      return u"smtpServerError";
+      return "smtpServerError";
     case NS_MSG_UNABLE_TO_SEND_LATER:
-      return u"unableToSendLater";
+      return "unableToSendLater";
     case NS_ERROR_COMMUNICATIONS_ERROR:
-      return u"communicationsError";
+      return "communicationsError";
     case NS_ERROR_BUT_DONT_SHOW_ALERT:
-      return u"dontShowAlert";
+      return "dontShowAlert";
     case NS_ERROR_TCP_READ_ERROR:
-      return u"tcpReadError";
+      return "tcpReadError";
     case NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS:
-      return u"couldNotGetUsersMailAddress";
+      return "couldNotGetUsersMailAddress";
     case NS_ERROR_MIME_MPART_ATTACHMENT_ERROR:
-      return u"mimeMpartAttachmentError";
+      return "mimeMpartAttachmentError";
     case NS_MSG_FAILED_COPY_OPERATION:
-      return u"failedCopyOperation";
+      return "failedCopyOperation";
     case NS_ERROR_NNTP_NO_CROSS_POSTING:
-      return u"nntpNoCrossPosting";
+      return "nntpNoCrossPosting";
     case NS_MSG_CANCELLING:
-      return u"msgCancelling";
+      return "msgCancelling";
     case NS_ERROR_SEND_FAILED_BUT_NNTP_OK:
-      return u"sendFailedButNntpOk";
+      return "sendFailedButNntpOk";
     case NS_MSG_ERROR_READING_FILE:
-      return u"errorReadingFile";
+      return "errorReadingFile";
     case NS_MSG_ERROR_ATTACHING_FILE:
-      return u"errorAttachingFile";
+      return "errorAttachingFile";
     case NS_ERROR_SMTP_GREETING:
-      return u"incorrectSmtpGreeting";
+      return "incorrectSmtpGreeting";
     case NS_ERROR_SENDING_RCPT_COMMAND:
-      return u"errorSendingRcptCommand";
+      return "errorSendingRcptCommand";
     case NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS:
-      return u"startTlsFailed";
+      return "startTlsFailed";
     case NS_ERROR_SMTP_PASSWORD_UNDEFINED:
-      return u"smtpPasswordUndefined";
+      return "smtpPasswordUndefined";
     case NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED:
-      return u"smtpTempSizeExceeded";
+      return "smtpTempSizeExceeded";
     case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1:
-      return u"smtpPermSizeExceeded1";
+      return "smtpPermSizeExceeded1";
     case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2:
-      return u"smtpPermSizeExceeded2";
+      return "smtpPermSizeExceeded2";
     case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER:
-      return u"smtpSendFailedUnknownServer";
+      return "smtpSendFailedUnknownServer";
     case NS_ERROR_SMTP_SEND_FAILED_REFUSED:
-      return u"smtpSendRequestRefused";
+      return "smtpSendRequestRefused";
     case NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED:
-      return u"smtpSendInterrupted";
+      return "smtpSendInterrupted";
     case NS_ERROR_SMTP_SEND_FAILED_TIMEOUT:
-      return u"smtpSendTimeout";
+      return "smtpSendTimeout";
     case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON:
-      return u"smtpSendFailedUnknownReason";
+      return "smtpSendFailedUnknownReason";
     case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL:
-      return u"smtpHintAuthEncryptToPlainNoSsl";
+      return "smtpHintAuthEncryptToPlainNoSsl";
     case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL:
-      return u"smtpHintAuthEncryptToPlainSsl";
+      return "smtpHintAuthEncryptToPlainSsl";
     case NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT:
-      return u"smtpHintAuthPlainToEncrypt";
+      return "smtpHintAuthPlainToEncrypt";
     case NS_ERROR_SMTP_AUTH_FAILURE:
-      return u"smtpAuthFailure";
+      return "smtpAuthFailure";
     case NS_ERROR_SMTP_AUTH_GSSAPI:
-      return u"smtpAuthGssapi";
+      return "smtpAuthGssapi";
     case NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED:
-      return u"smtpAuthMechNotSupported";
+      return "smtpAuthMechNotSupported";
     case NS_ERROR_SMTP_AUTH_NOT_SUPPORTED:
-      return u"smtpAuthenticationNotSupported";
+      return "smtpAuthenticationNotSupported";
     case NS_ERROR_ILLEGAL_LOCALPART:
-      return u"illegalLocalPart";
+      return "illegalLocalPart";
     default:
-      return u"sendFailed";
+      return "sendFailed";
   }
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
 }
--- a/mailnews/compose/src/nsComposeStrings.h
+++ b/mailnews/compose/src/nsComposeStrings.h
@@ -67,11 +67,11 @@
 #define NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT         NS_MSG_GENERATE_FAILURE(12596)
 #define NS_ERROR_SMTP_AUTH_FAILURE                  NS_MSG_GENERATE_FAILURE(12597)
 #define NS_ERROR_SMTP_AUTH_GSSAPI                   NS_MSG_GENERATE_FAILURE(12598)
 #define NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED       NS_MSG_GENERATE_FAILURE(12599)
 #define NS_ERROR_SMTP_AUTH_NOT_SUPPORTED            NS_MSG_GENERATE_FAILURE(12600)
 
 #define NS_ERROR_ILLEGAL_LOCALPART                  NS_MSG_GENERATE_FAILURE(12601)
 
-const char16_t* errorStringNameForErrorCode(nsresult aCode);
+const char* errorStringNameForErrorCode(nsresult aCode);
 
 #endif /* _nsComposeStrings_H__ */
--- a/mailnews/compose/src/nsMsgAttachmentHandler.cpp
+++ b/mailnews/compose/src/nsMsgAttachmentHandler.cpp
@@ -1160,20 +1160,20 @@ nsMsgAttachmentHandler::UrlExit(nsresult
         params = unescapedUrl;
     }
     else
       params.AssignLiteral("?");
 
     NS_ConvertUTF8toUTF16 UTF16params(params);
     const char16_t* formatParams[] = { UTF16params.get() };
     if (mode == nsIMsgSend::nsMsgSaveAsDraft || mode == nsIMsgSend::nsMsgSaveAsTemplate)
-      bundle->FormatStringFromName(u"failureOnObjectEmbeddingWhileSaving",
+      bundle->FormatStringFromName("failureOnObjectEmbeddingWhileSaving",
                                    formatParams, 1, getter_Copies(msg));
     else
-      bundle->FormatStringFromName(u"failureOnObjectEmbeddingWhileSending",
+      bundle->FormatStringFromName("failureOnObjectEmbeddingWhileSending",
                                    formatParams, 1, getter_Copies(msg));
 
     nsCOMPtr<nsIPrompt> aPrompt;
     if (m_mime_delivery_state)
       m_mime_delivery_state->GetDefaultPrompt(getter_AddRefs(aPrompt));
     nsMsgAskBooleanQuestionByString(aPrompt, msg.get(), &keepOnGoing);
 
     if (keepOnGoing)
--- a/mailnews/compose/src/nsMsgCompUtils.cpp
+++ b/mailnews/compose/src/nsMsgCompUtils.cpp
@@ -434,17 +434,17 @@ nsresult mime_generate_headers(nsIMsgCom
           mozilla::services::GetStringBundleService();
         if (stringService)
         {
           nsCOMPtr<nsIStringBundle> composeStringBundle;
           rv = stringService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(composeStringBundle));
           if (NS_SUCCEEDED(rv))
           {
             nsString undisclosedRecipients;
-            rv = composeStringBundle->GetStringFromName(u"undisclosedRecipients",
+            rv = composeStringBundle->GetStringFromName("undisclosedRecipients",
                                                         getter_Copies(undisclosedRecipients));
             if (NS_SUCCEEDED(rv) && !undisclosedRecipients.IsEmpty())
             {
               nsCOMPtr<nsIMsgHeaderParser> headerParser(
                 mozilla::services::GetHeaderParser());
               nsCOMPtr<msgIAddressObject> group;
               headerParser->MakeGroupObject(undisclosedRecipients,
                 nullptr, 0, getter_AddRefs(group));
--- a/mailnews/compose/src/nsMsgCompose.cpp
+++ b/mailnews/compose/src/nsMsgCompose.cpp
@@ -1489,28 +1489,28 @@ NS_IMETHODIMP nsMsgCompose::SendMsg(MSG_
     else
     {
       /* If we come here it's because we got an error before we could intialize a
          send report! Let's try our best...
       */
       switch (deliverMode)
       {
         case nsIMsgCompDeliverMode::Later:
-          nsMsgDisplayMessageByName(prompt, u"unableToSendLater");
+          nsMsgDisplayMessageByName(prompt, "unableToSendLater");
           break;
         case nsIMsgCompDeliverMode::AutoSaveAsDraft:
         case nsIMsgCompDeliverMode::SaveAsDraft:
-          nsMsgDisplayMessageByName(prompt, u"unableToSaveDraft");
+          nsMsgDisplayMessageByName(prompt, "unableToSaveDraft");
           break;
         case nsIMsgCompDeliverMode::SaveAsTemplate:
-          nsMsgDisplayMessageByName(prompt, u"unableToSaveTemplate");
+          nsMsgDisplayMessageByName(prompt, "unableToSaveTemplate");
           break;
 
         default:
-          nsMsgDisplayMessageByName(prompt, u"sendFailed");
+          nsMsgDisplayMessageByName(prompt, "sendFailed");
           break;
       }
     }
 
     if (progress)
       progress->CloseProgressDialog(true);
   }
 
@@ -2177,17 +2177,17 @@ nsresult nsMsgCompose::CreateMessage(con
                 nsresult rv;
                 nsCOMPtr<nsIStringBundleService> bundleService =
                   mozilla::services::GetStringBundleService();
                 NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
                 nsCOMPtr<nsIStringBundle> composeBundle;
                 rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties",
                                                  getter_AddRefs(composeBundle));
                 NS_ENSURE_SUCCESS(rv, rv);
-                composeBundle->GetStringFromName(u"messageAttachmentSafeName",
+                composeBundle->GetStringFromName("messageAttachmentSafeName",
                                                  getter_Copies(sanitizedSubj));
               }
               else
                 sanitizedSubj.Assign(subject);
 
               // set the file size
               uint32_t messageSize;
               msgHdr->GetMessageSize(&messageSize);
@@ -2848,17 +2848,17 @@ NS_IMETHODIMP QuotingOutputStreamListene
         {
           nsCOMPtr<mozIDOMWindowProxy> domWindow;
           nsCOMPtr<nsIPrompt> prompt;
           compose->GetDomWindow(getter_AddRefs(domWindow));
           NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
           nsCOMPtr<nsPIDOMWindowOuter> composeWindow = nsPIDOMWindowOuter::From(domWindow);
           if (composeWindow)
             composeWindow->GetPrompter(getter_AddRefs(prompt));
-          nsMsgDisplayMessageByName(prompt, u"followupToSenderMessage");
+          nsMsgDisplayMessageByName(prompt, "followupToSenderMessage");
 
           if (!replyTo.IsEmpty())
           {
             compFields->SetTo(replyTo);
           }
           else
           {
             // If reply-to is empty, use the From header to fetch the original
@@ -4051,17 +4051,17 @@ NS_IMETHODIMP nsMsgComposeSendListener::
             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);
           nsString msg;
-          bundle->GetStringFromName(u"msgCancelling", getter_Copies(msg));
+          bundle->GetStringFromName("msgCancelling", getter_Copies(msg));
           progress->OnStatusChange(nullptr, nullptr, NS_OK, msg.get());
         }
       }
 
       nsCOMPtr<nsIMsgSend> msgSend;
       msgCompose->GetMessageSend(getter_AddRefs(msgSend));
       if (msgSend)
         msgSend->Abort();
--- a/mailnews/compose/src/nsMsgPrompts.cpp
+++ b/mailnews/compose/src/nsMsgPrompts.cpp
@@ -10,34 +10,34 @@
 #include "nsMsgCompCID.h"
 #include "nsComposeStrings.h"
 #include "nsIStringBundle.h"
 #include "nsServiceManagerUtils.h"
 #include "nsMsgUtils.h"
 #include "mozilla/Services.h"
 
 nsresult
-nsMsgGetMessageByName(const char16_t* aName, nsString& aResult)
+nsMsgGetMessageByName(const char* aName, 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);
 
   return bundle->GetStringFromName(aName, getter_Copies(aResult));
 }
 
 static nsresult
-nsMsgBuildMessageByName(const char16_t *aName, nsIFile *aFile, nsString& aResult)
+nsMsgBuildMessageByName(const char *aName, nsIFile *aFile, nsString& aResult)
 {
   NS_ENSURE_ARG_POINTER(aFile);
   nsresult rv;
   nsCOMPtr<nsIStringBundleService> bundleService =
     mozilla::services::GetStringBundleService();
   NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
 
   nsCOMPtr<nsIStringBundle> bundle;
@@ -49,27 +49,27 @@ nsMsgBuildMessageByName(const char16_t *
 
   const char16_t *params[1] = {path.get()};
   return bundle->FormatStringFromName(aName, params, 1, getter_Copies(aResult));
 }
 
 nsresult
 nsMsgBuildMessageWithFile(nsIFile *aFile, nsString& aResult)
 {
-  return nsMsgBuildMessageByName(u"unableToOpenFile", aFile, aResult);
+  return nsMsgBuildMessageByName("unableToOpenFile", aFile, aResult);
 }
 
 nsresult
 nsMsgBuildMessageWithTmpFile(nsIFile *aFile, nsString& aResult)
 {
-  return nsMsgBuildMessageByName(u"unableToOpenTmpFile", aFile, aResult);
+  return nsMsgBuildMessageByName("unableToOpenTmpFile", aFile, aResult);
 }
 
 nsresult
-nsMsgDisplayMessageByName(nsIPrompt *aPrompt, const char16_t* aName, const char16_t *windowTitle)
+nsMsgDisplayMessageByName(nsIPrompt *aPrompt, const char* aName, const char16_t *windowTitle)
 {
   nsString msg;
   nsMsgGetMessageByName(aName, msg);
   return nsMsgDisplayMessageByString(aPrompt, msg.get(), windowTitle);
 }
 
 nsresult
 nsMsgDisplayMessageByString(nsIPrompt * aPrompt, const char16_t * msg, const char16_t * windowTitle)
--- a/mailnews/compose/src/nsMsgPrompts.h
+++ b/mailnews/compose/src/nsMsgPrompts.h
@@ -7,16 +7,16 @@
 #define _nsMsgPrompts_H_
 
 #include "nscore.h"
 #include "nsError.h"
 #include "nsString.h"
 
 class nsIPrompt;
 
-nsresult      nsMsgGetMessageByName(const char16_t* aName, nsString& aResult);
+nsresult      nsMsgGetMessageByName(const char* aName, nsString& aResult);
 nsresult      nsMsgBuildMessageWithFile(nsIFile * aFile, nsString& aResult);
 nsresult      nsMsgBuildMessageWithTmpFile(nsIFile * aFile, nsString& aResult);
-nsresult      nsMsgDisplayMessageByName(nsIPrompt *aPrompt, const char16_t *aName, const char16_t *windowTitle = nullptr);
+nsresult      nsMsgDisplayMessageByName(nsIPrompt *aPrompt, const char *aName, const char16_t *windowTitle = nullptr);
 nsresult      nsMsgDisplayMessageByString(nsIPrompt * aPrompt, const char16_t * msg, const char16_t * windowTitle = nullptr);
 nsresult      nsMsgAskBooleanQuestionByString(nsIPrompt * aPrompt, const char16_t * msg, bool *answer, const char16_t * windowTitle = nullptr);
 
 #endif /* _nsMsgPrompts_H_ */
--- a/mailnews/compose/src/nsMsgSend.cpp
+++ b/mailnews/compose/src/nsMsgSend.cpp
@@ -558,17 +558,17 @@ nsMsgComposeAndSend::GatherMimeAttachmen
 
   /* Kludge to avoid having to allocate memory on the toy computers... */
   buffer = mime_get_stream_write_buffer();
   if (! buffer)
     goto FAILMEM;
 
   NS_ASSERTION (m_attachment_pending_count == 0, "m_attachment_pending_count != 0");
 
-  mComposeBundle->GetStringFromName(u"assemblingMessage",
+  mComposeBundle->GetStringFromName("assemblingMessage",
                                     getter_Copies(msg));
   SetStatusMessage( msg );
 
   /* First, open the message file.
   */
   rv = nsMsgCreateTempFile("nsemail.eml", getter_AddRefs(mTempFile));
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -925,17 +925,17 @@ nsMsgComposeAndSend::GatherMimeAttachmen
         if (m_attachments[i]->mMHTMLPart)
           PreProcessPart(m_attachments[i], m_related_part);
       }
     }
 
   }
 
   // Tell the user we are creating the message...
-  mComposeBundle->GetStringFromName(u"creatingMailMessage",
+  mComposeBundle->GetStringFromName("creatingMailMessage",
                                     getter_Copies(msg));
   SetStatusMessage( msg );
 
   // OK, now actually write the structure we've carefully built up.
   status = toppart->Write();
   if (NS_FAILED(status))
     goto FAIL;
 
@@ -968,17 +968,17 @@ nsMsgComposeAndSend::GatherMimeAttachmen
     rv = mTempFile->GetFileSize(&fileSize);
     if (NS_FAILED(rv) || fileSize == 0)
     {
       status = NS_MSG_ERROR_WRITING_FILE;
       goto FAIL;
     }
   }
 
-  mComposeBundle->GetStringFromName(u"assemblingMessageDone",
+  mComposeBundle->GetStringFromName("assemblingMessageDone",
                                     getter_Copies(msg));
   SetStatusMessage(msg);
 
   if (m_dont_deliver_p && mListener)
   {
     //
     // Need to ditch the file spec here so that we don't delete the
     // file, since in this case, the caller wants the file
@@ -2520,17 +2520,17 @@ nsMsgComposeAndSend::HackAttachments(nsI
       if (!params.IsEmpty()) {
         formatParams[0] = params.get();
       } else if (m_attachments[i]->mURL) {
         nsCString asciiSpec;
         m_attachments[i]->mURL->GetAsciiSpec(asciiSpec);
         attachmentFileName.AssignASCII(asciiSpec.get());
         formatParams[0] = attachmentFileName.get();
       }
-      mComposeBundle->FormatStringFromName(u"gatheringAttachment",
+      mComposeBundle->FormatStringFromName("gatheringAttachment",
                                            formatParams, 1, getter_Copies(msg));
 
       if (!msg.IsEmpty())
       {
         SetStatusMessage(msg);
       }
 
       /* As SnarfAttachment will call GatherMimeAttachments when it will be done (this is an async process),
@@ -2548,17 +2548,17 @@ nsMsgComposeAndSend::HackAttachments(nsI
           m_attachments[i]->mURL->GetAsciiSpec(asciiSpec);
           attachmentFileName.AssignASCII(asciiSpec.get());
           rv = NS_OK;
         }
         if (NS_SUCCEEDED(rv))
         {
           nsCOMPtr<nsIStringBundle> bundle;
           const char16_t *params[] = { attachmentFileName.get() };
-          mComposeBundle->FormatStringFromName(u"errorAttachingFile",
+          mComposeBundle->FormatStringFromName("errorAttachingFile",
                                                params, 1,
                                                getter_Copies(errorMsg));
           mSendReport->SetMessage(nsIMsgSendReport::process_Current, errorMsg.get(), false);
           mSendReport->SetError(nsIMsgSendReport::process_Current,
                                 NS_MSG_ERROR_ATTACHING_FILE,
                                 false);
         }
         return NS_MSG_ERROR_ATTACHING_FILE;
@@ -3040,17 +3040,17 @@ nsMsgComposeAndSend::Init(
       mozilla::services::GetStringBundleService();
     NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
     nsCOMPtr<nsIStringBundle> bundle;
     rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(mComposeBundle));
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // Tell the user we are assembling the message...
-  mComposeBundle->GetStringFromName(u"assemblingMailInformation", getter_Copies(msg));
+  mComposeBundle->GetStringFromName("assemblingMailInformation", getter_Copies(msg));
   SetStatusMessage(msg);
   if (mSendReport)
     mSendReport->SetCurrentProcess(nsIMsgSendReport::process_BuildMessage);
 
   //
   // The Init() method should initialize a send operation for full
   // blown create and send operations as well as just the "send a file"
   // operations.
@@ -3243,17 +3243,17 @@ nsMsgComposeAndSend::DeliverMessage()
 
   if ((mMessageWarningSize > 0) && (fileSize > mMessageWarningSize) && (mGUINotificationEnabled))
   {
     bool abortTheSend = false;
     nsString msg;
     nsAutoString formattedFileSize;
     FormatFileSize(fileSize, true, formattedFileSize);
     const char16_t* params[] = { formattedFileSize.get() };
-    mComposeBundle->FormatStringFromName(u"largeMessageSendWarning",
+    mComposeBundle->FormatStringFromName("largeMessageSendWarning",
                                          params, 1, getter_Copies(msg));
 
     if (!msg.IsEmpty())
     {
       nsCOMPtr<nsIPrompt> prompt;
       GetDefaultPrompt(getter_AddRefs(prompt));
       nsMsgAskBooleanQuestionByString(prompt, msg.get(), &abortTheSend);
       if (!abortTheSend)
@@ -3402,17 +3402,17 @@ nsMsgComposeAndSend::DeliverFileAsMail()
     // to the top most mail window...after all, that's where we are going to be sending status
     // update information too....
 
     nsCOMPtr<nsIInterfaceRequestor> callbacks;
     GetNotificationCallbacks(getter_AddRefs(callbacks));
 
     // Tell the user we are sending the message!
     nsString msg;
-    mComposeBundle->GetStringFromName(u"sendingMessage", getter_Copies(msg));
+    mComposeBundle->GetStringFromName("sendingMessage", getter_Copies(msg));
     SetStatusMessage(msg);
     nsCOMPtr<nsIMsgStatusFeedback> msgStatus (do_QueryInterface(mSendProgress));
     // if the sendProgress isn't set, let's use the member variable.
     if (!msgStatus)
       msgStatus = do_QueryInterface(mStatusFeedback);
 
     nsCOMPtr<nsIURI> runningUrl;
     rv = smtpService->SendMailMessage(mTempFile, buf, mUserIdentity,
@@ -3451,17 +3451,17 @@ nsMsgComposeAndSend::DeliverFileAsNews()
   if (NS_SUCCEEDED(rv) && nntpService)
   {
     MsgDeliveryListener *deliveryListener = new MsgDeliveryListener(this, true);
     if (!deliveryListener)
       return NS_ERROR_OUT_OF_MEMORY;
 
     // Tell the user we are posting the message!
     nsString msg;
-    mComposeBundle->GetStringFromName(u"postingMessage",
+    mComposeBundle->GetStringFromName("postingMessage",
                                       getter_Copies(msg));
     SetStatusMessage(msg);
 
     nsCOMPtr <nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
 
     // JFD TODO: we should use GetDefaultPrompt instead
     nsCOMPtr<nsIMsgWindow> msgWindow;
@@ -3501,31 +3501,31 @@ nsMsgComposeAndSend::Fail(nsresult aFail
       }
       mSendReport->SetError(nsIMsgSendReport::process_Current, aFailureCode, false);
       mSendReport->SetMessage(nsIMsgSendReport::process_Current, aErrorMsg, false);
       mSendReport->DisplayReport(prompt, true, true, aResult);
     }
     else
     {
       if (aFailureCode != NS_ERROR_BUT_DONT_SHOW_ALERT)
-        nsMsgDisplayMessageByName(prompt, u"sendFailed");
+        nsMsgDisplayMessageByName(prompt, "sendFailed");
     }
   }
 
   if (NS_SUCCEEDED(m_status))
     m_status = NS_ERROR_BUT_DONT_SHOW_ALERT;
 
   //Stop any pending process...
   Abort();
 
   return NS_OK;
 }
 
 nsresult
-nsMsgComposeAndSend::FormatStringWithSMTPHostNameByName(const char16_t* aMsgName, char16_t **aString)
+nsMsgComposeAndSend::FormatStringWithSMTPHostNameByName(const char* aMsgName, char16_t **aString)
 {
   NS_ENSURE_ARG(aString);
 
   nsresult rv;
   nsCOMPtr<nsISmtpService> smtpService(do_GetService(NS_SMTPSERVICE_CONTRACTID, &rv));
   NS_ENSURE_SUCCESS(rv,rv);
 
   // Get the smtp hostname and format the string.
@@ -3545,17 +3545,17 @@ nsMsgComposeAndSend::FormatStringWithSMT
 
 void
 nsMsgComposeAndSend::DoDeliveryExitProcessing(nsIURI * aUri, nsresult aExitCode, bool aCheckForMail)
 {
   // If we fail on the news delivery, no sense in going on so just notify
   // the user and exit.
   if (NS_FAILED(aExitCode))
   {
-    const char16_t* exitString = errorStringNameForErrorCode(aExitCode);
+    const char* exitString = errorStringNameForErrorCode(aExitCode);
     nsString eMsg;
     if (aExitCode == NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER ||
         aExitCode == NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON ||
         aExitCode == NS_ERROR_SMTP_SEND_FAILED_REFUSED ||
         aExitCode == NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED ||
         aExitCode == NS_ERROR_SMTP_SEND_FAILED_TIMEOUT ||
         aExitCode == NS_ERROR_SMTP_PASSWORD_UNDEFINED ||
         aExitCode == NS_ERROR_SMTP_AUTH_FAILURE ||
@@ -3830,19 +3830,19 @@ NS_IMETHODIMP
 nsMsgComposeAndSend::NotifyListenerOnStopCopy(nsresult aStatus)
 {
   // This is one per copy so make sure we clean this up first.
   mCopyObj = nullptr;
 
   // Set a status message...
   nsString msg;
   if (NS_SUCCEEDED(aStatus))
-    mComposeBundle->GetStringFromName(u"copyMessageComplete", getter_Copies(msg));
+    mComposeBundle->GetStringFromName("copyMessageComplete", getter_Copies(msg));
   else
-    mComposeBundle->GetStringFromName(u"copyMessageFailed", getter_Copies(msg));
+    mComposeBundle->GetStringFromName("copyMessageFailed", getter_Copies(msg));
 
   SetStatusMessage(msg);
   nsCOMPtr<nsIPrompt> prompt;
   GetDefaultPrompt(getter_AddRefs(prompt));
 
   if (NS_FAILED(aStatus))
   {
     nsresult rv;
@@ -3893,42 +3893,42 @@ nsMsgComposeAndSend::NotifyListenerOnSto
     const char16_t *formatStrings[] = { mSavedToFolderName.get(), accountName.get(),
                                         localFoldersAccountName.get() };
 
     nsString msg;
     switch (m_deliver_mode)
     {
       case nsMsgDeliverNow:
       case nsMsgSendUnsent:
-        rv = bundle->FormatStringFromName(u"promptToSaveSentLocally",
+        rv = bundle->FormatStringFromName("promptToSaveSentLocally",
                                           formatStrings, 3,
                                           getter_Copies(msg));
         break;
       case nsMsgSaveAsDraft:
-        rv = bundle->FormatStringFromName(u"promptToSaveDraftLocally",
+        rv = bundle->FormatStringFromName("promptToSaveDraftLocally",
                                           formatStrings, 3,
                                           getter_Copies(msg));
         break;
       case nsMsgSaveAsTemplate:
-        rv = bundle->FormatStringFromName(u"promptToSaveTemplateLocally",
+        rv = bundle->FormatStringFromName("promptToSaveTemplateLocally",
                                           formatStrings, 3,
                                           getter_Copies(msg));
         break;
       default:
         rv = NS_ERROR_UNEXPECTED;
     }
     NS_ENSURE_SUCCESS(rv, rv);
     int32_t buttonPressed = 0;
     bool showCheckBox = false;
     uint32_t buttonFlags = (nsIPrompt::BUTTON_POS_0 * nsIPrompt::BUTTON_TITLE_IS_STRING) +
                            (nsIPrompt::BUTTON_POS_1 * nsIPrompt::BUTTON_TITLE_CANCEL) +
                            (nsIPrompt::BUTTON_POS_2 * nsIPrompt::BUTTON_TITLE_SAVE);
     nsString dialogTitle, buttonLabelRetry;
-    bundle->GetStringFromName(u"SaveDialogTitle", getter_Copies(dialogTitle));
-    bundle->GetStringFromName(u"buttonLabelRetry", getter_Copies(buttonLabelRetry));
+    bundle->GetStringFromName("SaveDialogTitle", getter_Copies(dialogTitle));
+    bundle->GetStringFromName("buttonLabelRetry", getter_Copies(buttonLabelRetry));
     prompt->ConfirmEx(dialogTitle.get(), msg.get(), buttonFlags, buttonLabelRetry.get(),
                       nullptr, nullptr, nullptr, &showCheckBox, &buttonPressed);
     if (buttonPressed == 0)
     {
       // retry button clicked
       mSendProgress = nullptr; // this was canceled, so we need to clear it.
       return SendToMagicFolder(m_deliver_mode);
     }
@@ -3947,17 +3947,17 @@ nsMsgComposeAndSend::NotifyListenerOnSto
                      nullptr,
                      mCompFields->GetNewspostUrl());
 
       if (NS_FAILED(rv))
       {
         // Save to Local Folders failed. Inform the user.
         nsCOMPtr<nsIPrompt> prompt;
         GetDefaultPrompt(getter_AddRefs(prompt));
-        nsMsgDisplayMessageByName(prompt, u"saveToLocalFoldersFailed");
+        nsMsgDisplayMessageByName(prompt, "saveToLocalFoldersFailed");
       }
     }
 
     // Failure detected when user saved to default folder and the user did not
     // retry; instead the user saved to Local Folders or canceled the save. So
     // just call Fail() with a success code so that it doesn't prompt the user
     // again since the user already knows about the failure and has reacted.
     Fail(NS_OK, nullptr, &aStatus);
@@ -4012,25 +4012,25 @@ nsMsgComposeAndSend::FilterSentMessage()
 }
 
 NS_IMETHODIMP
 nsMsgComposeAndSend::OnStopOperation(nsresult aStatus)
 {
   // Set a status message...
   nsString msg;
   if (NS_SUCCEEDED(aStatus))
-    mComposeBundle->GetStringFromName(u"filterMessageComplete", getter_Copies(msg));
+    mComposeBundle->GetStringFromName("filterMessageComplete", getter_Copies(msg));
   else
-    mComposeBundle->GetStringFromName(u"filterMessageFailed", getter_Copies(msg));
+    mComposeBundle->GetStringFromName("filterMessageFailed", getter_Copies(msg));
 
   SetStatusMessage(msg);
 
   if (NS_FAILED(aStatus))
   {
-    nsresult rv = mComposeBundle->GetStringFromName(u"errorFilteringMsg", getter_Copies(msg));
+    nsresult rv = mComposeBundle->GetStringFromName("errorFilteringMsg", getter_Copies(msg));
     if (NS_SUCCEEDED(rv))
     {
       nsCOMPtr<nsIPrompt> prompt;
       GetDefaultPrompt(getter_AddRefs(prompt));
       nsMsgDisplayMessageByString(prompt, msg.get(), nullptr);
     }
 
     // We failed, however, give Fail a success code so that it doesn't prompt
@@ -4479,17 +4479,17 @@ nsMsgComposeAndSend::MimeDoFCC(nsIFile  
   {
     GetFolderURIFromUserPrefs(mode, mUserIdentity, tmpUri);
   }
   status = MessageFolderIsLocal(mUserIdentity, mode, tmpUri.get(), &folderIsLocal);
   if (NS_FAILED(status))
     goto FAIL;
 
   // Tell the user we are copying the message...
-  mComposeBundle->GetStringFromName(u"copyMessageStart",
+  mComposeBundle->GetStringFromName("copyMessageStart",
                                     getter_Copies(msg));
   if (!msg.IsEmpty())
   {
     nsCOMPtr<nsIRDFService> rdfService = do_GetService(kRDFServiceCID);
     if (rdfService)
     {
       nsCOMPtr<nsIRDFResource> res;
       rdfService->GetResource(tmpUri, getter_AddRefs(res));
--- a/mailnews/compose/src/nsMsgSend.h
+++ b/mailnews/compose/src/nsMsgSend.h
@@ -184,17 +184,17 @@ public:
   nsMsgComposeAndSend();
 
 
   // Delivery and completion callback routines...
   NS_IMETHOD  DeliverMessage();
   NS_IMETHOD  DeliverFileAsMail();
   NS_IMETHOD  DeliverFileAsNews();
   void        DoDeliveryExitProcessing(nsIURI * aUrl, nsresult aExitCode, bool aCheckForMail);
-  nsresult    FormatStringWithSMTPHostNameByName(const char16_t* aMsgName, char16_t **aString);
+  nsresult    FormatStringWithSMTPHostNameByName(const char* aMsgName, char16_t **aString);
 
   nsresult    DoFcc();
   nsresult    StartMessageCopyOperation(nsIFile          *aFileSpec,
                                         nsMsgDeliverMode mode,
                                         const nsCString& dest_uri);
 
 
   nsresult SendToMagicFolder(nsMsgDeliverMode flag);
--- a/mailnews/compose/src/nsMsgSendLater.cpp
+++ b/mailnews/compose/src/nsMsgSendLater.cpp
@@ -246,17 +246,17 @@ nsMsgSendLater::OnStopRequest(nsIRequest
     nsCOMPtr<nsIPrompt> promptObject;
     if (channel)
     {
       channel->GetURI(getter_AddRefs(uri));
       nsCOMPtr<nsISmtpUrl> smtpUrl (do_QueryInterface(uri));
       if (smtpUrl)
         smtpUrl->GetPrompt(getter_AddRefs(promptObject));
     }
-    nsMsgDisplayMessageByName(promptObject, u"errorQueuedDeliveryFailed");
+    nsMsgDisplayMessageByName(promptObject, "errorQueuedDeliveryFailed");
 
     // Getting the data failed, but we will still keep trying to send the rest...
     rv = StartNextMailFileSend(status);
     if (NS_FAILED(rv))
       EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
   }
 
   return rv;
--- a/mailnews/compose/src/nsMsgSendReport.cpp
+++ b/mailnews/compose/src/nsMsgSendReport.cpp
@@ -286,17 +286,17 @@ NS_IMETHODIMP nsMsgSendReport::DisplayRe
       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:
-        const char16_t* errorString = errorStringNameForErrorCode(currError);
+        const char* errorString = errorStringNameForErrorCode(currError);
         nsMsgGetMessageByName(errorString, currMessage);
         break;
     }
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
   }
 
@@ -305,56 +305,56 @@ NS_IMETHODIMP nsMsgSendReport::DisplayRe
     // 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->GetStringFromName(u"sendMessageErrorTitle",
+    bundle->GetStringFromName("sendMessageErrorTitle",
                               getter_Copies(dialogTitle));
 
-    const char16_t* preStrName = u"sendFailed";
+    const char* preStrName = "sendFailed";
     bool askToGoBackToCompose = false;
     switch (mCurrentProcess)
     {
       case process_BuildMessage :
-        preStrName = u"sendFailed";
+        preStrName = "sendFailed";
         askToGoBackToCompose = false;
         break;
       case process_NNTP :
-        preStrName = u"sendFailed";
+        preStrName = "sendFailed";
         askToGoBackToCompose = false;
         break;
       case process_SMTP :
         bool nntpProceeded;
         mProcessReport[process_NNTP]->GetProceeded(&nntpProceeded);
         if (nntpProceeded)
-          preStrName = u"sendFailedButNntpOk";
+          preStrName = "sendFailedButNntpOk";
         else
-          preStrName = u"sendFailed";
+          preStrName = "sendFailed";
         askToGoBackToCompose = false;
         break;
       case process_Copy:
-        preStrName = u"failedCopyOperation";
+        preStrName = "failedCopyOperation";
         askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
         break;
       case process_FCC:
-        preStrName = u"failedCopyOperation";
+        preStrName = "failedCopyOperation";
         askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
         break;
     }
     bundle->GetStringFromName(preStrName, 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->GetStringFromName(u"genericFailureExplanation",
+      bundle->GetStringFromName("genericFailureExplanation",
                                 getter_Copies(currMessage));
     }
 
     if (!currMessage.IsEmpty())
     {
       //Don't need to repeat ourself!
       if (!currMessage.Equals(dialogMessage))
       {
@@ -363,67 +363,67 @@ NS_IMETHODIMP nsMsgSendReport::DisplayRe
         dialogMessage.Append(currMessage);
       }
     }
 
     if (askToGoBackToCompose)
     {
       bool oopsGiveMeBackTheComposeWindow = true;
       nsString text1;
-      bundle->GetStringFromName(u"returnToComposeWindowQuestion",
+      bundle->GetStringFromName("returnToComposeWindowQuestion",
                                 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
   {
-    const char16_t* title;
-    const char16_t* messageName;
+    const char* title;
+    const char* messageName;
 
     switch (mDeliveryMode)
     {
       case nsIMsgCompDeliverMode::Later:
-        title = u"sendLaterErrorTitle";
-        messageName = u"unableToSendLater";
+        title = "sendLaterErrorTitle";
+        messageName = "unableToSendLater";
         break;
 
       case nsIMsgCompDeliverMode::AutoSaveAsDraft:
       case nsIMsgCompDeliverMode::SaveAsDraft:
-        title = u"saveDraftErrorTitle";
-        messageName = u"unableToSaveDraft";
+        title = "saveDraftErrorTitle";
+        messageName = "unableToSaveDraft";
         break;
 
       case nsIMsgCompDeliverMode::SaveAsTemplate:
-        title = u"saveTemplateErrorTitle";
-        messageName = u"unableToSaveTemplate";
+        title = "saveTemplateErrorTitle";
+        messageName = "unableToSaveTemplate";
         break;
 
       default:
         /* This should never happen! */
-        title = u"sendMessageErrorTitle";
-        messageName = u"sendFailed";
+        title = "sendMessageErrorTitle";
+        messageName = "sendFailed";
         break;
     }
 
     bundle->GetStringFromName(title, getter_Copies(dialogTitle));
     bundle->GetStringFromName(messageName,
                               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->GetStringFromName(u"genericFailureExplanation",
+      bundle->GetStringFromName("genericFailureExplanation",
                                 getter_Copies(currMessage));
     }
 
     if (!currMessage.IsEmpty())
     {
       if (!dialogMessage.IsEmpty())
         dialogMessage.Append(char16_t('\n'));
       dialogMessage.Append(currMessage);
--- a/mailnews/compose/src/nsSmtpProtocol.cpp
+++ b/mailnews/compose/src/nsSmtpProtocol.cpp
@@ -89,26 +89,26 @@ nsresult nsExplainErrorDetails(nsISmtpUr
   nsCOMPtr<nsIStringBundle> bundle;
   nsresult rv = bundleService->CreateBundle(
     "chrome://messenger/locale/messengercompose/composeMsgs.properties",
     getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   va_start (args, aCode);
 
-  const char16_t* exitString;
+  const char* exitString;
 #ifdef __GNUC__
 // Temporary workaroung until bug 783526 is fixed.
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch"
 #endif
   switch (aCode)
   {
     case NS_ERROR_ILLEGAL_LOCALPART:
-      bundle->GetStringFromName(u"errorIllegalLocalPart",
+      bundle->GetStringFromName("errorIllegalLocalPart",
                                 getter_Copies(eMsg));
       msg = nsTextFormatter::vsmprintf(eMsg.get(), args);
       break;
     case NS_ERROR_SMTP_SERVER_ERROR:
     case NS_ERROR_TCP_READ_ERROR:
     case NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED:
     case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1:
     case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2:
@@ -118,17 +118,17 @@ nsresult nsExplainErrorDetails(nsISmtpUr
     case NS_ERROR_SENDING_MESSAGE:
     case NS_ERROR_SMTP_GREETING:
       exitString = errorStringNameForErrorCode(aCode);
       bundle->GetStringFromName(exitString, getter_Copies(eMsg));
       msg = nsTextFormatter::vsmprintf(eMsg.get(), args);
       break;
     default:
       NS_WARNING("falling to default error code");
-      bundle->GetStringFromName(u"communicationsError", getter_Copies(eMsg));
+      bundle->GetStringFromName("communicationsError", getter_Copies(eMsg));
       msg = nsTextFormatter::smprintf(eMsg.get(), aCode);
       break;
   }
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
 
   if (msg)
@@ -567,17 +567,17 @@ NS_IMETHODIMP nsSmtpProtocol::OnStopRequ
 
   return rv;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 // End of nsIStreamListenerSupport
 //////////////////////////////////////////////////////////////////////////////////////////////
 
-void nsSmtpProtocol::UpdateStatus(const char16_t* aStatusName)
+void nsSmtpProtocol::UpdateStatus(const char* aStatusName)
 {
   if (m_statusFeedback)
   {
     nsCOMPtr<nsIStringBundleService> bundleService =
       mozilla::services::GetStringBundleService();
     if (!bundleService) return;
     nsCOMPtr<nsIStringBundle> bundle;
     nsresult rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
@@ -1843,17 +1843,17 @@ nsresult nsSmtpProtocol::SendDataRespons
 
     m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
     return(NS_ERROR_SENDING_DATA_COMMAND);
   }
 
   m_nextState = SMTP_SEND_POST_DATA;
   ClearFlag(SMTP_PAUSE_FOR_READ);   /* send data directly */
 
-  UpdateStatus(u"smtpDeliveringMail");
+  UpdateStatus("smtpDeliveringMail");
 
   {
 //      m_runningURL->GetBodySize(&m_totalMessageSize);
   }
   return(status);
 }
 
 void nsSmtpProtocol::SendMessageInFile()
@@ -1866,17 +1866,17 @@ void nsSmtpProtocol::SendMessageInFile()
     // in some windows header file
     nsMsgAsyncWriteProtocol::PostMessage(url, file);
 
   SetFlag(SMTP_PAUSE_FOR_READ);
 
   // for now, we are always done at this point..we aren't making multiple calls
   // to post data...
 
-  UpdateStatus(u"smtpDeliveringMail");
+  UpdateStatus("smtpDeliveringMail");
   m_nextState = SMTP_RESPONSE;
   m_nextStateAfterResponse = SMTP_SEND_MESSAGE_RESPONSE;
 }
 
 void nsSmtpProtocol::SendPostData()
 {
 	// mscott: as a first pass, I'm writing everything at once and am not
 	// doing it in chunks...
@@ -1911,17 +1911,17 @@ nsresult nsSmtpProtocol::SendMessageResp
                                                             NS_ERROR_SENDING_MESSAGE,
                                                             m_responseText.get());
     NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
 
     m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
     return(NS_ERROR_SENDING_MESSAGE);
   }
 
-  UpdateStatus(u"smtpMailSent");
+  UpdateStatus("smtpMailSent");
 
   /* else */
   return SendQuit();
 }
 
 nsresult nsSmtpProtocol::SendQuit(SmtpState aNextStateAfterResponse)
 {
   m_sendDone = true;
@@ -2214,31 +2214,31 @@ nsSmtpProtocol::PromptForPassword(nsISmt
 
   nsCOMPtr<nsIStringBundle> composeStringBundle;
   nsresult rv = stringService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(composeStringBundle));
   NS_ENSURE_SUCCESS(rv,rv);
 
   nsString passwordPromptString;
   if(formatStrings[1])
     rv = composeStringBundle->FormatStringFromName(
-      u"smtpEnterPasswordPromptWithUsername",
+      "smtpEnterPasswordPromptWithUsername",
       formatStrings, 2, getter_Copies(passwordPromptString));
   else
     rv = composeStringBundle->FormatStringFromName(
-      u"smtpEnterPasswordPrompt",
+      "smtpEnterPasswordPrompt",
       formatStrings, 1, getter_Copies(passwordPromptString));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIAuthPrompt> netPrompt;
   rv = aSmtpUrl->GetAuthPrompt(getter_AddRefs(netPrompt));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString passwordTitle;
   rv = composeStringBundle->GetStringFromName(
-    u"smtpEnterPasswordPromptTitle",
+    "smtpEnterPasswordPromptTitle",
     getter_Copies(passwordTitle));
   NS_ENSURE_SUCCESS(rv,rv);
 
   rv = aSmtpServer->GetPasswordWithUI(passwordPromptString.get(), passwordTitle.get(),
     netPrompt, aPassword);
   NS_ENSURE_SUCCESS(rv,rv);
   return rv;
 }
--- a/mailnews/compose/src/nsSmtpProtocol.h
+++ b/mailnews/compose/src/nsSmtpProtocol.h
@@ -160,17 +160,17 @@ private:
     nsresult LoadUrlInternal(nsIURI *aURL, nsISupports *aConsumer);
     virtual nsresult ProcessProtocolState(nsIURI * url, nsIInputStream * inputStream, 
                                           uint64_t sourceOffset, uint32_t length) override;
 
     ////////////////////////////////////////////////////////////////////////////////////////
     // Communication methods --> Reading and writing protocol
     ////////////////////////////////////////////////////////////////////////////////////////
 
-    void UpdateStatus(const char16_t* aStatusName);
+    void UpdateStatus(const char* aStatusName);
     void UpdateStatusWithString(const char16_t * aStatusString);
 
     ////////////////////////////////////////////////////////////////////////////////////////
     // Protocol Methods --> This protocol is state driven so each protocol method is 
     //						designed to re-act to the current "state". I've attempted to 
     //						group them together based on functionality. 
     ////////////////////////////////////////////////////////////////////////////////////////
 
--- a/mailnews/extensions/mailviews/src/nsMsgMailViewList.cpp
+++ b/mailnews/extensions/mailviews/src/nsMsgMailViewList.cpp
@@ -69,25 +69,25 @@ NS_IMETHODIMP nsMsgMailView::GetPrettyNa
                                     getter_AddRefs(mBundle));
     }
 
     NS_ENSURE_TRUE(mBundle, NS_ERROR_FAILURE);
 
     // see if mName has an associated pretty name inside our string bundle and if so, use that as the pretty name
     // otherwise just return mName
     if (mName.EqualsLiteral(kDefaultViewPeopleIKnow))
-        rv = mBundle->GetStringFromName(u"mailViewPeopleIKnow", aMailViewName);
+        rv = mBundle->GetStringFromName("mailViewPeopleIKnow", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewRecent))
-        rv = mBundle->GetStringFromName(u"mailViewRecentMail", aMailViewName);
+        rv = mBundle->GetStringFromName("mailViewRecentMail", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewFiveDays))
-        rv = mBundle->GetStringFromName(u"mailViewLastFiveDays", aMailViewName);
+        rv = mBundle->GetStringFromName("mailViewLastFiveDays", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewNotJunk))
-        rv = mBundle->GetStringFromName(u"mailViewNotJunk", aMailViewName);
+        rv = mBundle->GetStringFromName("mailViewNotJunk", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewHasAttachments))
-        rv = mBundle->GetStringFromName(u"mailViewHasAttachments", aMailViewName);
+        rv = mBundle->GetStringFromName("mailViewHasAttachments", aMailViewName);
     else
         *aMailViewName = ToNewUnicode(mName);
 
     return rv;
 }
 
 NS_IMETHODIMP nsMsgMailView::GetSearchTerms(nsIMutableArray **aSearchTerms)
 {
--- a/mailnews/extensions/mdn/src/nsMsgMdnGenerator.cpp
+++ b/mailnews/extensions/mdn/src/nsMsgMdnGenerator.cpp
@@ -94,17 +94,17 @@ nsMsgMdnGenerator::nsMsgMdnGenerator()
     m_outsideDomainOp = eNeverSendOp;
     m_otherOp = eNeverSendOp;
 }
 
 nsMsgMdnGenerator::~nsMsgMdnGenerator()
 {
 }
 
-nsresult nsMsgMdnGenerator::FormatStringFromName(const char16_t *aName,
+nsresult nsMsgMdnGenerator::FormatStringFromName(const char *aName,
                                                  const char16_t *aString,
                                                  char16_t **aResultString)
 {
     DEBUG_MDN("nsMsgMdnGenerator::FormatStringFromName");
 
     nsCOMPtr<nsIStringBundleService> bundleService =
       mozilla::services::GetStringBundleService();
     NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
@@ -116,17 +116,17 @@ nsresult nsMsgMdnGenerator::FormatString
 
     const char16_t *formatStrings[1] = { aString };
     rv = bundle->FormatStringFromName(aName,
                     formatStrings, 1, aResultString);
     NS_ENSURE_SUCCESS(rv,rv);
     return rv;
 }
 
-nsresult nsMsgMdnGenerator::GetStringFromName(const char16_t *aName,
+nsresult nsMsgMdnGenerator::GetStringFromName(const char *aName,
                                                char16_t **aResultString)
 {
     DEBUG_MDN("nsMsgMdnGenerator::GetStringFromName");
 
     nsCOMPtr<nsIStringBundleService> bundleService =
       mozilla::services::GetStringBundleService();
     NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
 
@@ -467,17 +467,17 @@ nsresult nsMsgMdnGenerator::CreateFirstP
     // convert fullName to UTF8 before passing it to MakeMimeAddress
     MakeMimeAddress(NS_ConvertUTF16toUTF8(fullName), m_email, fullAddress);
 
     convbuf = nsMsgI18NEncodeMimePartIIStr(fullAddress.get(),
         true, m_charset.get(), 0, conformToStandard);
 
     parm = PR_smprintf("From: %s" CRLF, convbuf ? convbuf : m_email.get());
 
-    rv = FormatStringFromName(u"MsgMdnMsgSentTo", NS_ConvertASCIItoUTF16(m_email).get(),
+    rv = FormatStringFromName("MsgMdnMsgSentTo", NS_ConvertASCIItoUTF16(m_email).get(),
                             getter_Copies(firstPart1));
     if (NS_FAILED(rv))
         return rv;
 
     PUSH_N_FREE_STRING (parm);
 
     PR_Free(convbuf);
 
@@ -489,42 +489,42 @@ nsresult nsMsgMdnGenerator::CreateFirstP
       PUSH_N_FREE_STRING(tmpBuffer);
     }
 
     nsString receipt_string;
     switch (m_disposeType)
     {
     case nsIMsgMdnGenerator::eDisplayed:
         rv = GetStringFromName(
-            u"MdnDisplayedReceipt",
+            "MdnDisplayedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eDispatched:
         rv = GetStringFromName(
-            u"MdnDispatchedReceipt",
+            "MdnDispatchedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eProcessed:
         rv = GetStringFromName(
-            u"MdnProcessedReceipt",
+            "MdnProcessedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eDeleted:
         rv = GetStringFromName(
-            u"MdnDeletedReceipt",
+            "MdnDeletedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eDenied:
         rv = GetStringFromName(
-            u"MdnDeniedReceipt",
+            "MdnDeniedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eFailed:
         rv = GetStringFromName(
-            u"MdnFailedReceipt",
+            "MdnFailedReceipt",
             getter_Copies(receipt_string));
         break;
     default:
         rv = NS_ERROR_INVALID_ARG;
         break;
     }
 
     if (NS_FAILED(rv))
@@ -590,42 +590,42 @@ report-type=disposition-notification;\r\
         tmpBuffer = PR_smprintf("%s" CRLF CRLF, NS_ConvertUTF16toUTF8(firstPart1).get());
         PUSH_N_FREE_STRING(tmpBuffer);
     }
 
     switch (m_disposeType)
     {
     case nsIMsgMdnGenerator::eDisplayed:
         rv = GetStringFromName(
-            u"MsgMdnDisplayed",
+            "MsgMdnDisplayed",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eDispatched:
         rv = GetStringFromName(
-            u"MsgMdnDispatched",
+            "MsgMdnDispatched",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eProcessed:
         rv = GetStringFromName(
-            u"MsgMdnProcessed",
+            "MsgMdnProcessed",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eDeleted:
         rv = GetStringFromName(
-            u"MsgMdnDeleted",
+            "MsgMdnDeleted",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eDenied:
         rv = GetStringFromName(
-            u"MsgMdnDenied",
+            "MsgMdnDenied",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eFailed:
         rv = GetStringFromName(
-            u"MsgMdnFailed",
+            "MsgMdnFailed",
             getter_Copies(firstPart2));
         break;
     default:
         rv = NS_ERROR_INVALID_ARG;
         break;
     }
 
     if (NS_FAILED(rv))
@@ -1073,35 +1073,35 @@ NS_IMETHODIMP nsMsgMdnGenerator::OnStopR
 
     DEBUG_MDN("nsMsgMdnGenerator::OnStopRunningUrl");
     if (m_file)
       m_file->Remove(false);
 
     if (NS_SUCCEEDED(aExitCode))
       return NS_OK;
 
-    const char16_t* exitString;
+    const char* exitString;
 
     switch (aExitCode)
     {
       case NS_ERROR_UNKNOWN_HOST:
       case NS_ERROR_UNKNOWN_PROXY_HOST:
-        exitString = u"smtpSendFailedUnknownServer";
+        exitString = "smtpSendFailedUnknownServer";
         break;
       case NS_ERROR_CONNECTION_REFUSED:
       case NS_ERROR_PROXY_CONNECTION_REFUSED:
-        exitString = u"smtpSendRequestRefused";
+        exitString = "smtpSendRequestRefused";
         break;
       case NS_ERROR_NET_INTERRUPT:
       case NS_ERROR_ABORT: // we have no proper string for error code NS_ERROR_ABORT in compose bundle
-        exitString = u"smtpSendInterrupted";
+        exitString = "smtpSendInterrupted";
         break;
       case NS_ERROR_NET_TIMEOUT:
       case NS_ERROR_NET_RESET:
-        exitString = u"smtpSendTimeout";
+        exitString = "smtpSendTimeout";
         break;
       default:
         exitString = errorStringNameForErrorCode(aExitCode);
         break;
     }
 
     nsCOMPtr<nsISmtpService> smtpService(do_GetService(NS_SMTPSERVICE_CONTRACTID, &rv));
     NS_ENSURE_SUCCESS(rv,rv);
@@ -1125,17 +1125,17 @@ NS_IMETHODIMP nsMsgMdnGenerator::OnStopR
     rv = bundleService->CreateBundle(
       "chrome://messenger/locale/messengercompose/composeMsgs.properties",
       getter_AddRefs(bundle));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsString failed_msg, dialogTitle;
 
     bundle->FormatStringFromName(exitString, params, 1, getter_Copies(failed_msg));
-    bundle->GetStringFromName(u"sendMessageErrorTitle", getter_Copies(dialogTitle));
+    bundle->GetStringFromName("sendMessageErrorTitle", 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;
 }
--- a/mailnews/extensions/mdn/src/nsMsgMdnGenerator.h
+++ b/mailnews/extensions/mdn/src/nsMsgMdnGenerator.h
@@ -47,18 +47,18 @@ private:
 
   nsresult CreateMdnMsg();
   nsresult CreateFirstPart();
   nsresult CreateSecondPart();
   nsresult CreateThirdPart();
   nsresult SendMdnMsg();
 
   // string bundle helper methods
-  nsresult GetStringFromName(const char16_t *aName, char16_t **aResultString);
-  nsresult FormatStringFromName(const char16_t *aName,
+  nsresult GetStringFromName(const char *aName, char16_t **aResultString);
+  nsresult FormatStringFromName(const char *aName,
                                 const char16_t *aString,
                                 char16_t **aResultString);
 
   // other helper methods
   nsresult InitAndProcess(bool *needToAskUser);
   nsresult OutputAllHeaders();
   nsresult WriteString(const char *str);
 
--- a/mailnews/extensions/smime/src/nsMsgComposeSecure.cpp
+++ b/mailnews/extensions/smime/src/nsMsgComposeSecure.cpp
@@ -185,22 +185,22 @@ nsresult nsMsgComposeSecure::GetSMIMEBun
                                                   nsString &outString)
 {
   outString.Truncate();
 
   NS_ENSURE_ARG_POINTER(name);
 
   NS_ENSURE_TRUE(InitializeSMIMEBundle(), NS_ERROR_FAILURE);
 
-  return mSMIMEBundle->GetStringFromName(name, getter_Copies(outString));
+  return mSMIMEBundle->GetStringFromName(NS_ConvertUTF16toUTF8(name).get(), getter_Copies(outString));
 }
 
 nsresult
 nsMsgComposeSecure::
-SMIMEBundleFormatStringFromName(const char16_t *name,
+SMIMEBundleFormatStringFromName(const char *name,
                                 const char16_t **params,
                                 uint32_t numParams,
                                 char16_t **outString)
 {
   NS_ENSURE_ARG_POINTER(name);
 
   if (!InitializeSMIMEBundle())
     return NS_ERROR_FAILURE;
@@ -238,17 +238,17 @@ void nsMsgComposeSecure::SetError(nsIMsg
   if (NS_SUCCEEDED(res) && !errorString.IsEmpty())
   {
     sendReport->SetMessage(nsIMsgSendReport::process_Current,
                            errorString.get(),
                            true);
   }
 }
 
-void nsMsgComposeSecure::SetErrorWithParam(nsIMsgSendReport *sendReport, const char16_t *bundle_string, const char *param)
+void nsMsgComposeSecure::SetErrorWithParam(nsIMsgSendReport *sendReport, const char *bundle_string, const char *param)
 {
   if (!sendReport || !bundle_string || !param)
     return;
 
   if (mErrorAlreadyReported)
     return;
 
   mErrorAlreadyReported = true;
@@ -554,17 +554,17 @@ nsresult nsMsgComposeSecure::MimeInitEnc
   nsCOMPtr<nsIStringBundle> sMIMEBundle;
   nsString mime_smime_enc_content_desc;
 
   bundleSvc->CreateBundle(SMIME_STRBUNDLE_URL, getter_AddRefs(sMIMEBundle));
 
   if (!sMIMEBundle)
     return NS_ERROR_FAILURE;
 
-  sMIMEBundle->GetStringFromName(u"mime_smimeEncryptedContentDesc",
+  sMIMEBundle->GetStringFromName("mime_smimeEncryptedContentDesc",
                                  getter_Copies(mime_smime_enc_content_desc));
   NS_ConvertUTF16toUTF8 enc_content_desc_utf8(mime_smime_enc_content_desc);
 
   nsCOMPtr<nsIMimeConverter> mimeConverter =
      do_GetService(NS_MIME_CONVERTER_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   nsCString encodedContentDescription;
   mimeConverter->EncodeMimePartIIStr_UTF8(enc_content_desc_utf8, false, "UTF-8",
@@ -670,17 +670,17 @@ nsresult nsMsgComposeSecure::MimeFinishM
   nsCOMPtr<nsIStringBundle> sMIMEBundle;
   nsString mime_smime_sig_content_desc;
 
   bundleSvc->CreateBundle(SMIME_STRBUNDLE_URL, getter_AddRefs(sMIMEBundle));
 
   if (!sMIMEBundle)
     return NS_ERROR_FAILURE;
 
-  sMIMEBundle->GetStringFromName(u"mime_smimeSignatureContentDesc",
+  sMIMEBundle->GetStringFromName("mime_smimeSignatureContentDesc",
                                  getter_Copies(mime_smime_sig_content_desc));
 
   NS_ConvertUTF16toUTF8 sig_content_desc_utf8(mime_smime_sig_content_desc);
 
   /* Compute the hash...
    */
 
   nsAutoCString hashString;
@@ -965,17 +965,17 @@ nsresult nsMsgComposeSecure::MimeCryptoH
       ToLowerCase(mailboxes[i], mailbox_lowercase);
       nsCOMPtr<nsIX509Cert> cert;
       res = certdb->FindCertByEmailAddress(mailbox_lowercase,
                                            getter_AddRefs(cert));
       if (NS_FAILED(res)) {
         // Failure to find a valid encryption cert is fatal.
         // Here I assume that mailbox is ascii rather than utf8.
         SetErrorWithParam(sendReport,
-                          u"MissingRecipientEncryptionCert",
+                          "MissingRecipientEncryptionCert",
                           mailboxes[i].get());
 
         return res;
       }
 
     /* #### see if recipient requests `signedData'.
      if (...) no_clearsigning_p = true;
      (This is the only reason we even bother looking up the certs
--- a/mailnews/extensions/smime/src/nsMsgComposeSecure.h
+++ b/mailnews/extensions/smime/src/nsMsgComposeSecure.h
@@ -63,17 +63,17 @@ private:
   virtual ~nsMsgComposeSecure();
   typedef mozilla::mailnews::MimeEncoder MimeEncoder;
   nsresult MimeInitMultipartSigned(bool aOuter, nsIMsgSendReport *sendReport);
   nsresult MimeInitEncryption(bool aSign, nsIMsgSendReport *sendReport);
   nsresult MimeFinishMultipartSigned (bool aOuter, nsIMsgSendReport *sendReport);
   nsresult MimeFinishEncryption (bool aSign, nsIMsgSendReport *sendReport);
   nsresult MimeCryptoHackCerts(const char *aRecipients, nsIMsgSendReport *sendReport, bool aEncrypt, bool aSign, nsIMsgIdentity *aIdentity);
   bool InitializeSMIMEBundle();
-  nsresult SMIMEBundleFormatStringFromName(const char16_t *name,
+  nsresult SMIMEBundleFormatStringFromName(const char *name,
 					   const char16_t **params,
 					   uint32_t numParams,
 					   char16_t **outString);
   nsresult ExtractEncryptionState(nsIMsgIdentity * aIdentity, nsIMsgCompFields * aComposeFields, bool * aSignMessage, bool * aEncrypt);
 
   mimeDeliveryCryptoState mCryptoState;
   nsCOMPtr<nsIOutputStream> mStream;
   int16_t mHashType;
@@ -95,12 +95,12 @@ private:
   bool mIsDraft;
 
   enum {eBufferSize = 8192};
   char *mBuffer;
   uint32_t mBufferedBytes;
 
   bool mErrorAlreadyReported;
   void SetError(nsIMsgSendReport *sendReport, const char16_t *bundle_string);
-  void SetErrorWithParam(nsIMsgSendReport *sendReport, const char16_t *bundle_string, const char *param);
+  void SetErrorWithParam(nsIMsgSendReport *sendReport, const char *bundle_string, const char *param);
 };
 
 #endif
--- a/mailnews/imap/src/nsImapIncomingServer.cpp
+++ b/mailnews/imap/src/nsImapIncomingServer.cpp
@@ -1861,17 +1861,17 @@ nsImapIncomingServer::FEAlert(const nsAS
     nsresult rv = GetPrettyName(hostName);
     if (NS_SUCCEEDED(rv))
     {
       nsString message;
       nsString tempString(aAlertString);
       const char16_t *params[] = { hostName.get(), tempString.get() };
 
       rv = m_stringBundle->FormatStringFromName(
-        u"imapServerAlert",
+        "imapServerAlert",
         params, 2, getter_Copies(message));
       if (NS_SUCCEEDED(rv))
         return AlertUser(message, aUrl);
     }
   }
   return AlertUser(aAlertString, aUrl);
 }
 
@@ -1900,17 +1900,17 @@ nsImapIncomingServer::FEAlertWithName(co
   if (m_stringBundle)
   {
     nsAutoString hostName;
     nsresult rv = GetPrettyName(hostName);
     if (NS_SUCCEEDED(rv))
     {
       const char16_t *params[] = { hostName.get() };
       rv = m_stringBundle->FormatStringFromName(
-        NS_ConvertASCIItoUTF16(aMsgName).get(),
+        aMsgName,
         params, 1,getter_Copies(message));
       if (NS_SUCCEEDED(rv))
         return AlertUser(message, aUrl);
     }
   }
 
   // Error condition
   message.AssignLiteral("String Name ");
@@ -1946,17 +1946,17 @@ NS_IMETHODIMP  nsImapIncomingServer::FEA
 
   const char16_t *formatStrings[] =
   {
     hostName.get(),
     nullptr,
     nullptr
   };
 
-  nsString msgName;
+  const char* msgName;
   int32_t numStrings;
   nsString fullMessage;
   nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aUrl);
   NS_ENSURE_TRUE(imapUrl, NS_ERROR_INVALID_ARG);
 
   nsImapState imapState;
   nsImapAction imapAction;
 
@@ -1969,32 +1969,32 @@ NS_IMETHODIMP  nsImapIncomingServer::FEA
   nsCOMPtr<nsIMsgFolder> folder;
   if (imapState == nsIImapUrl::nsImapSelectedState ||
       imapAction == nsIImapUrl::nsImapFolderStatus)
   {
     aUrl->GetFolder(getter_AddRefs(folder));
     if (folder)
       folder->GetPrettyName(folderName);
     numStrings = 3;
-    msgName.AssignLiteral("imapFolderCommandFailed");
+    msgName = "imapFolderCommandFailed";
     formatStrings[1] = folderName.get();
   }
   else
   {
-    msgName.AssignLiteral("imapServerCommandFailed");
+    msgName = "imapServerCommandFailed";
     numStrings = 2;
   }
 
   formatStrings[numStrings -1] = unicodeMsg.get();
 
   nsresult rv = GetStringBundle();
   NS_ENSURE_SUCCESS(rv, rv);
   if (m_stringBundle)
   {
-    rv = m_stringBundle->FormatStringFromName(msgName.get(),
+    rv = m_stringBundle->FormatStringFromName(msgName,
       formatStrings, numStrings, getter_Copies(fullMessage));
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return AlertUser(fullMessage, aUrl);
 }
 
 #define IMAP_MSGS_URL       "chrome://messenger/locale/imapMsgs.properties"
@@ -2013,19 +2013,17 @@ nsresult nsImapIncomingServer::GetString
 NS_IMETHODIMP
 nsImapIncomingServer::GetImapStringByName(const char* msgName, nsAString& aString)
 {
   nsresult rv = NS_OK;
   GetStringBundle();
   if (m_stringBundle)
   {
     nsString res_str;
-    rv = m_stringBundle->GetStringFromName(
-       NS_ConvertASCIItoUTF16(msgName).get(),
-       getter_Copies(res_str));
+    rv = m_stringBundle->GetStringFromName(msgName, getter_Copies(res_str));
     aString.Assign(res_str);
     if (NS_SUCCEEDED(rv))
       return rv;
   }
   aString.AssignLiteral("String Name ");
   // mscott: FIX ME
   aString.AppendASCII(msgName);
   return NS_OK;
@@ -2202,17 +2200,17 @@ nsImapIncomingServer::PromptPassword(nsI
 
   NS_ConvertASCIItoUTF16 finalUserName(userName);
   NS_ConvertASCIItoUTF16 finalHostName(hostName);
 
   const char16_t *formatStrings[] = { finalUserName.get(), finalHostName.get() };
 
   nsString passwordText;
   rv = m_stringBundle->FormatStringFromName(
-    u"imapEnterServerPasswordPrompt",
+    "imapEnterServerPasswordPrompt",
     formatStrings, 2, getter_Copies(passwordText));
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = GetPasswordWithUI(passwordText, passwordTitle, aMsgWindow, aPassword);
   if (NS_SUCCEEDED(rv))
     m_password = aPassword;
   return rv;
 }
@@ -2941,17 +2939,17 @@ nsImapIncomingServer::GetFormattedString
   nsresult rv = GetStringBundle();
   if (m_stringBundle)
   {
     nsString tmpVal (aValue);
     const char16_t *formatStrings[] = { tmpVal.get() };
 
     nsString result;
     rv = m_stringBundle->FormatStringFromName(
-      NS_ConvertASCIItoUTF16(aName).get(),
+      aName,
       formatStrings, 1, getter_Copies(result));
     aResult.Assign(result);
   }
   return rv;
 }
 
 nsresult
 nsImapIncomingServer::GetPrefForServerAttribute(const char *prefSuffix, bool *prefValue)
--- a/mailnews/imap/src/nsImapMailFolder.cpp
+++ b/mailnews/imap/src/nsImapMailFolder.cpp
@@ -1602,30 +1602,30 @@ NS_IMETHODIMP nsImapMailFolder::Rename (
       if (NS_SUCCEEDED(rv) && bundle)
       {
         const char16_t *formatStrings[] =
         {
           (const char16_t*)(intptr_t)m_hierarchyDelimiter
         };
         nsString alertString;
         rv = bundle->FormatStringFromName(
-          u"imapSpecialChar",
+          "imapSpecialChar",
           formatStrings, 1, getter_Copies(alertString));
         nsCOMPtr<nsIPrompt> dialog(do_GetInterface(docShell));
         // setting up the dialog title
         nsCOMPtr<nsIMsgIncomingServer> server;
         rv = GetServer(getter_AddRefs(server));
         NS_ENSURE_SUCCESS(rv, rv);
         nsString dialogTitle;
         nsString accountName;
         rv = server->GetPrettyName(accountName);
         NS_ENSURE_SUCCESS(rv, rv);
         const char16_t *titleParams[] = { accountName.get() };
         rv = bundle->FormatStringFromName(
-          u"imapAlertDialogTitle",
+          "imapAlertDialogTitle",
           titleParams, 1, getter_Copies(dialogTitle));
 
         if (dialog && !alertString.IsEmpty())
           dialog->Alert(dialogTitle.get(), alertString.get());
       }
     }
     return NS_ERROR_FAILURE;
   }
@@ -2424,30 +2424,30 @@ nsImapMailFolder::DeleteSubFolders(nsIAr
 
     nsAutoString folderName;
     rv = curFolder->GetName(folderName);
     NS_ENSURE_SUCCESS(rv, rv);
     const char16_t *formatStrings[1] = { folderName.get() };
 
     nsAutoString deleteFolderDialogTitle;
     rv = bundle->GetStringFromName(
-      u"imapDeleteFolderDialogTitle",
+      "imapDeleteFolderDialogTitle",
       getter_Copies(deleteFolderDialogTitle));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsAutoString deleteFolderButtonLabel;
     rv = bundle->GetStringFromName(
-      u"imapDeleteFolderButtonLabel",
+      "imapDeleteFolderButtonLabel",
       getter_Copies(deleteFolderButtonLabel));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsAutoString confirmationStr;
     rv = bundle->FormatStringFromName((deleteNoTrash) ?
-        u"imapDeleteNoTrash" :
-        u"imapMoveFolderToTrash",
+        "imapDeleteNoTrash" :
+        "imapMoveFolderToTrash",
       formatStrings, 1, getter_Copies(confirmationStr));
     NS_ENSURE_SUCCESS(rv, rv);
     if (!msgWindow)
       return NS_ERROR_NULL_POINTER;
     nsCOMPtr<nsIDocShell> docShell;
     msgWindow->GetRootDocShell(getter_AddRefs(docShell));
     nsCOMPtr<nsIPrompt> dialog;
     if (docShell)
@@ -6058,17 +6058,17 @@ nsImapMailFolder::FillInFolderProps(nsIM
     }
     else
     {
       // is this right? It doesn't leak, does it?
       CopyASCIItoUTF16(owner, uniOwner);
     }
     const char16_t *params[] = { uniOwner.get() };
     rv = bundle->FormatStringFromName(
-      u"imapOtherUsersFolderTypeDescription",
+      "imapOtherUsersFolderTypeDescription",
       params, 1, getter_Copies(folderTypeDesc));
   }
   else if (GetFolderACL()->GetIsFolderShared())
   {
     folderTypeStringID = "imapPersonalSharedFolderTypeName";
     folderTypeDescStringID = "imapPersonalSharedFolderTypeDescription";
   }
   else
@@ -6589,90 +6589,90 @@ nsresult nsMsgIMAPFolderACL::CreateACLRi
 {
   nsString curRight;
   nsCOMPtr<nsIStringBundle> bundle;
   nsresult rv = IMAPGetStringBundle(getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (GetDoIHaveFullRightsForFolder()) {
     nsAutoString result;
-    rv = bundle->GetStringFromName(u"imapAclFullRights",
+    rv = bundle->GetStringFromName("imapAclFullRights",
                                    getter_Copies(result));
     aRightsString.Assign(result);
     return rv;
   }
   else
   {
     if (GetCanIReadFolder())
     {
-      bundle->GetStringFromName(u"imapAclReadRight",
+      bundle->GetStringFromName("imapAclReadRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIWriteFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclWriteRight",
+      bundle->GetStringFromName("imapAclWriteRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIInsertInFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclInsertRight",
+      bundle->GetStringFromName("imapAclInsertRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanILookupFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclLookupRight",
+      bundle->GetStringFromName("imapAclLookupRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIStoreSeenInFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclSeenRight",
+      bundle->GetStringFromName("imapAclSeenRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIDeleteInFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclDeleteRight",
+      bundle->GetStringFromName("imapAclDeleteRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIExpungeFolder())
     {
       if (!aRightsString.IsEmpty())
         aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclExpungeRight",
+      bundle->GetStringFromName("imapAclExpungeRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanICreateSubfolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclCreateRight",
+      bundle->GetStringFromName("imapAclCreateRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIPostToFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclPostRight",
+      bundle->GetStringFromName("imapAclPostRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIAdministerFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(u"imapAclAdministerRight",
+      bundle->GetStringFromName("imapAclAdministerRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
   }
   return rv;
 }
 
 NS_IMETHODIMP nsImapMailFolder::GetFilePath(nsIFile ** aPathName)
@@ -8209,17 +8209,17 @@ nsImapMailFolder::CopyStreamMessage(nsIM
                                             totalMsgString.get(),
                                             dstFolderName.get()
                                             };
 
       nsCOMPtr <nsIStringBundle> bundle;
       rv = IMAPGetStringBundle(getter_AddRefs(bundle));
       NS_ENSURE_SUCCESS(rv, rv);
       rv = bundle->FormatStringFromName(
-        u"imapCopyingMessageOf2",
+        "imapCopyingMessageOf2",
         formatStrings, 3, getter_Copies(progressText));
       nsCOMPtr <nsIMsgStatusFeedback> statusFeedback;
       if (m_copyState->m_msgWindow)
         m_copyState->m_msgWindow->GetStatusFeedback(getter_AddRefs(statusFeedback));
       if (statusFeedback)
       {
         statusFeedback->ShowStatusString(progressText);
         int32_t percent;
--- a/mailnews/imap/src/nsImapProtocol.cpp
+++ b/mailnews/imap/src/nsImapProtocol.cpp
@@ -555,17 +555,17 @@ nsImapProtocol::Initialize(nsIImapHostSe
   m_hostSessionList = aHostSessionList; // no ref count...host session list has life time > connection
   m_parser.SetHostSessionList(aHostSessionList);
   m_parser.SetFlagState(m_flagState);
 
   // Initialize the empty mime part string on the main thread.
   rv = IMAPGetStringBundle(getter_AddRefs(m_bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = m_bundle->GetStringFromName(u"imapEmptyMimePart",
+  rv = m_bundle->GetStringFromName("imapEmptyMimePart",
     getter_Copies(m_emptyMimePartString));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Now initialize the thread for the connection
   if (m_thread == nullptr)
   {
     nsresult rv = NS_NewThread(getter_AddRefs(m_iThread), this);
     if (NS_FAILED(rv))
@@ -5196,23 +5196,23 @@ void nsImapProtocol::ResetProgressInfo()
 
 void nsImapProtocol::SetProgressString(uint32_t aStringIndex)
 {
   m_stringIndex = aStringIndex;
   MOZ_ASSERT(m_stringIndex <= IMAP_EMPTY_STRING_INDEX);
   switch (m_stringIndex)
   {
     case IMAP_HEADERS_STRING_INDEX:
-      m_progressStringName = u"imapReceivingMessageHeaders3";
+      m_progressStringName = "imapReceivingMessageHeaders3";
       break;
     case IMAP_MESSAGES_STRING_INDEX:
-      m_progressStringName = u"imapFolderReceivingMessageOf3";
+      m_progressStringName = "imapFolderReceivingMessageOf3";
       break;
     case IMAP_FLAGS_STRING_INDEX:
-      m_progressStringName = u"imapReceivingMessageFlags3";
+      m_progressStringName = "imapReceivingMessageFlags3";
       break;
     case IMAP_EMPTY_STRING_INDEX:
     default:
       break;
   }
 }
 
 void
--- a/mailnews/imap/src/nsImapProtocol.h
+++ b/mailnews/imap/src/nsImapProtocol.h
@@ -640,17 +640,17 @@ private:
   nsCString m_logonCookie;
   int16_t m_logonPort;
   
   nsString mAcceptLanguages;
   
   // progress stuff
   void SetProgressString(uint32_t aStringIndex);
   
-  nsString      m_progressStringName;
+  nsCString     m_progressStringName;
   uint32_t      m_stringIndex;
   int32_t       m_progressCurrentNumber[IMAP_NUMBER_OF_PROGRESS_STRINGS];
   int32_t       m_progressExpectedNumber;
   nsCString     m_lastProgressStringName;
   int32_t       m_lastPercent;
   int64_t       m_lastProgressTime;
   nsCOMPtr<nsIStringBundle> m_bundle;
 
--- a/mailnews/imap/src/nsImapService.cpp
+++ b/mailnews/imap/src/nsImapService.cpp
@@ -2744,17 +2744,17 @@ NS_IMETHODIMP nsImapService::NewChannel2
       NS_ENSURE_SUCCESS(rv, rv);
         // need to convert folder name from mod-utf7 to unicode
       nsAutoString unescapedName;
       if (NS_FAILED(CopyMUTF7toUTF16(fullFolderName, unescapedName)))
         CopyASCIItoUTF16(fullFolderName, unescapedName);
       const char16_t *formatStrings[1] = { unescapedName.get() };
 
       rv = bundle->FormatStringFromName(
-        u"imapSubscribePrompt",
+        "imapSubscribePrompt",
         formatStrings, 1, getter_Copies(confirmText));
       NS_ENSURE_SUCCESS(rv,rv);
 
       bool confirmResult = false;
       rv = dialog->Confirm(nullptr, confirmText.get(), &confirmResult);
       NS_ENSURE_SUCCESS(rv, rv);
 
       if (confirmResult)
--- a/mailnews/imap/src/nsImapStringBundle.cpp
+++ b/mailnews/imap/src/nsImapStringBundle.cpp
@@ -17,18 +17,17 @@
 
 extern "C" 
 nsresult
 IMAPGetStringByName(const char* stringName, char16_t **aString)
 {
   nsCOMPtr <nsIStringBundle> sBundle;
   nsresult rv = IMAPGetStringBundle(getter_AddRefs(sBundle));
   if (NS_SUCCEEDED(rv) && sBundle)
-    rv = sBundle->GetStringFromName(NS_ConvertASCIItoUTF16(stringName).get(),
-                                    aString);
+    rv = sBundle->GetStringFromName(stringName, aString);
   return rv;
 }
 
 nsresult
 IMAPGetStringBundle(nsIStringBundle **aBundle)
 {
   nsresult rv=NS_OK;
   nsCOMPtr<nsIStringBundleService> stringService =
--- a/mailnews/import/applemail/src/nsAppleMailImport.cpp
+++ b/mailnews/import/applemail/src/nsAppleMailImport.cpp
@@ -52,23 +52,23 @@ nsAppleMailImportModule::~nsAppleMailImp
 
 
 NS_IMPL_ISUPPORTS(nsAppleMailImportModule, nsIImportModule)
 
 
 NS_IMETHODIMP nsAppleMailImportModule::GetName(char16_t **aName)
 {
   return mBundle ?
-    mBundle->GetStringFromName(u"ApplemailImportName", aName) : NS_ERROR_FAILURE;
+    mBundle->GetStringFromName("ApplemailImportName", aName) : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP nsAppleMailImportModule::GetDescription(char16_t **aName)
 {
   return mBundle ?
-    mBundle->GetStringFromName(u"ApplemailImportDescription", aName) : NS_ERROR_FAILURE;
+    mBundle->GetStringFromName("ApplemailImportDescription", aName) : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP nsAppleMailImportModule::GetSupports(char **aSupports)
 {
   NS_ENSURE_ARG_POINTER(aSupports);
   *aSupports = strdup(NS_IMPORT_MAIL_STR);
   return NS_OK;
 }
@@ -91,17 +91,17 @@ NS_IMETHODIMP nsAppleMailImportModule::G
     nsCOMPtr<nsIImportMail> mail(do_CreateInstance(NS_APPLEMAILIMPL_CONTRACTID, &rv));
     if (NS_SUCCEEDED(rv)) {
       nsCOMPtr<nsIImportService> impSvc(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
       if (NS_SUCCEEDED(rv)) {
         nsCOMPtr<nsIImportGeneric> generic;
         rv = impSvc->CreateNewGenericMail(getter_AddRefs(generic));
         if (NS_SUCCEEDED(rv)) {
           nsAutoString name;
-          rv = mBundle->GetStringFromName(u"ApplemailImportName", getter_Copies(name));
+          rv = mBundle->GetStringFromName("ApplemailImportName", getter_Copies(name));
           NS_ENSURE_SUCCESS(rv, rv);
 
           nsCOMPtr<nsISupportsString> nameString(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv));
           NS_ENSURE_SUCCESS(rv, rv);
           nameString->SetData(name);
 
           generic->SetData("name", nameString);
           generic->SetData("mailInterface", mail);
@@ -582,17 +582,17 @@ nsAppleMailImportMail::ImportMailbox(nsI
 }
 
 void nsAppleMailImportMail::ReportStatus(const char16_t* aErrorName, nsString &aName,
                                          nsAString &aStream)
 {
   // get (and format, if needed) the error string from the bundle
   nsAutoString outString;
   const char16_t *fmt = { aName.get() };
-  nsresult rv = mBundle->FormatStringFromName(aErrorName, &fmt, 1, getter_Copies(outString));
+  nsresult rv = mBundle->FormatStringFromName(NS_ConvertUTF16toUTF8(aErrorName).get(), &fmt, 1, getter_Copies(outString));
   // write it out the stream
   if (NS_SUCCEEDED(rv)) {
     aStream.Append(outString);
     aStream.Append(char16_t('\n'));
   }
 }
 
 void nsAppleMailImportMail::SetLogs(const nsAString &aSuccess, const nsAString &aError, char16_t **aOutSuccess, char16_t **aOutError)
--- a/mailnews/import/becky/src/nsBeckyMail.cpp
+++ b/mailnews/import/becky/src/nsBeckyMail.cpp
@@ -610,17 +610,17 @@ nsBeckyMail::ImportMailbox(nsIImportMail
   mReadBytes = finalSize;
 
   nsAutoString name;
   aSource->GetDisplayName(getter_Copies(name));
 
   nsAutoString successMessage;
   const char16_t *format = { name.get() };
   rv =
-      nsBeckyStringBundle::FormatStringFromName(u"BeckyImportMailboxSuccess",
+      nsBeckyStringBundle::FormatStringFromName("BeckyImportMailboxSuccess",
                                                 &format,
                                                 1,
                                                 getter_Copies(successMessage));
   successMessage.AppendLiteral("\n");
   *aSuccessLog = ToNewUnicode(successMessage);
 
   return rv;
 }
--- a/mailnews/import/becky/src/nsBeckyStringBundle.cpp
+++ b/mailnews/import/becky/src/nsBeckyStringBundle.cpp
@@ -35,29 +35,29 @@ nsBeckyStringBundle::GetStringBundle(voi
 void
 nsBeckyStringBundle::EnsureStringBundle(void)
 {
   if (!mBundle)
     (void) GetStringBundle();
 }
 
 char16_t *
-nsBeckyStringBundle::GetStringByName(const char16_t *aName)
+nsBeckyStringBundle::GetStringByName(const char *aName)
 {
   EnsureStringBundle();
 
   char16_t *string = nullptr;
   if (mBundle)
     mBundle->GetStringFromName(aName, &string);
 
   return string;
 }
 
 nsresult
-nsBeckyStringBundle::FormatStringFromName(const char16_t *name,
+nsBeckyStringBundle::FormatStringFromName(const char *name,
                                           const char16_t **params,
                                           uint32_t length,
                                           char16_t **_retval)
 {
   EnsureStringBundle();
 
   return mBundle->FormatStringFromName(name,
                                        params,
--- a/mailnews/import/becky/src/nsBeckyStringBundle.h
+++ b/mailnews/import/becky/src/nsBeckyStringBundle.h
@@ -5,18 +5,18 @@
 #define _nsBeckyStringBundle_H__
 
 #include "nsString.h"
 
 class nsIStringBundle;
 
 class nsBeckyStringBundle final {
 public:
-  static char16_t *GetStringByName(const char16_t *name);
-  static nsresult FormatStringFromName(const char16_t *name,
+  static char16_t *GetStringByName(const char *name);
+  static nsresult FormatStringFromName(const char *name,
                                        const char16_t **params,
                                        uint32_t length,
                                        char16_t **_retval);
   static nsIStringBundle * GetStringBundle(void); // don't release
   static void EnsureStringBundle(void);
   static void Cleanup(void);
 private:
   static nsIStringBundle *mBundle;
--- a/mailnews/import/src/nsImportMail.cpp
+++ b/mailnews/import/src/nsImportMail.cpp
@@ -898,22 +898,22 @@ bool nsImportGenericMail::CreateFolder(n
   if (!bundleService)
       return false;
   rv = bundleService->CreateBundle(IMPORT_MSGS_URL, getter_AddRefs(bundle));
   if (NS_FAILED(rv))
       return false;
   nsString folderName;
   if (!m_pName.IsEmpty()) {
     const char16_t *moduleName[] = { m_pName.get() };
-    rv = bundle->FormatStringFromName(u"ImportModuleFolderName",
+    rv = bundle->FormatStringFromName("ImportModuleFolderName",
                                       moduleName, 1,
                                       getter_Copies(folderName));
   }
   else {
-    rv = bundle->GetStringFromName(u"DefaultFolderName",
+    rv = bundle->GetStringFromName("DefaultFolderName",
                                    getter_Copies(folderName));
   }
   if (NS_FAILED(rv)) {
       IMPORT_LOG0("*** Failed to get Folder Name!\n");
       return false;
   }
   nsCOMPtr <nsIMsgAccountManager> accMgr = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
   if (NS_FAILED(rv)) {
--- a/mailnews/import/src/nsImportStringBundle.cpp
+++ b/mailnews/import/src/nsImportStringBundle.cpp
@@ -60,18 +60,17 @@ void nsImportStringBundle::GetStringByNa
 }
 
 char16_t *nsImportStringBundle::GetStringByName(const char *aName,
                                                  nsIStringBundle *aBundle)
 {
   if (aBundle)
   {
     char16_t *ptrv = nullptr;
-    nsresult rv = aBundle->GetStringFromName(
-        NS_ConvertUTF8toUTF16(aName).get(), &ptrv);
+    nsresult rv = aBundle->GetStringFromName(aName, &ptrv);
 
     if (NS_SUCCEEDED(rv) && ptrv)
       return ptrv;
   }
 
   nsString resultString(NS_LITERAL_STRING("[StringName "));
   resultString.Append(NS_ConvertUTF8toUTF16(aName).get());
   resultString.AppendLiteral("?]");
--- a/mailnews/intl/nsCharsetConverterManager.cpp
+++ b/mailnews/intl/nsCharsetConverterManager.cpp
@@ -57,23 +57,23 @@ nsresult LoadExtensibleBundle(const char
 }
 
 static
 nsresult GetBundleValue(nsIStringBundle * aBundle,
                         const char * aName,
                         const nsString& aProp,
                         char16_t ** aResult)
 {
-  nsAutoString key; 
+  nsAutoString key;
 
   key.AssignWithConversion(aName);
   ToLowerCase(key); // we lowercase the main comparison key
   key.Append(aProp);
 
-  return aBundle->GetStringFromName(key.get(), aResult);
+  return aBundle->GetStringFromName(NS_ConvertUTF16toUTF8(key).get(), aResult);
 }
 
 static
 nsresult GetBundleValue(nsIStringBundle * aBundle,
                         const char * aName,
                         const nsString& aProp,
                         nsAString& aResult)
 {
--- a/mailnews/local/src/nsLocalMailFolder.cpp
+++ b/mailnews/local/src/nsLocalMailFolder.cpp
@@ -842,29 +842,29 @@ nsresult nsMsgLocalMailFolder::ConfirmFo
 
       nsAutoString folderName;
       rv = aFolder->GetName(folderName);
       NS_ENSURE_SUCCESS(rv, rv);
       const char16_t *formatStrings[1] = { folderName.get() };
 
       nsAutoString deleteFolderDialogTitle;
       rv = bundle->GetStringFromName(
-        u"pop3DeleteFolderDialogTitle",
+        "pop3DeleteFolderDialogTitle",
         getter_Copies(deleteFolderDialogTitle));
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsAutoString deleteFolderButtonLabel;
       rv = bundle->GetStringFromName(
-        u"pop3DeleteFolderButtonLabel",
+        "pop3DeleteFolderButtonLabel",
         getter_Copies(deleteFolderButtonLabel));
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsAutoString confirmationStr;
       rv = bundle->FormatStringFromName(
-        u"pop3MoveFolderToTrash", formatStrings, 1,
+        "pop3MoveFolderToTrash", formatStrings, 1,
         getter_Copies(confirmationStr));
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsCOMPtr<nsIPrompt> dialog(do_GetInterface(docShell));
       if (dialog)
       {
         int32_t buttonPressed = 0;
         // Default the dialog to "cancel".
@@ -3319,18 +3319,18 @@ nsresult nsMsgLocalMailFolder::DisplayMo
       numMsgSoFarString.AppendInt((mCopyState->m_copyingMultipleMessages) ? mCopyState->m_curCopyIndex : 1);
 
       nsAutoString totalMessagesString;
       totalMessagesString.AppendInt(mCopyState->m_totalMsgCount);
       nsString finalString;
       const char16_t * stringArray[] = { numMsgSoFarString.get(), totalMessagesString.get(), folderName.get() };
       rv = mCopyState->m_stringBundle->FormatStringFromName(
         (mCopyState->m_isMove) ?
-        u"movingMessagesStatus" :
-        u"copyingMessagesStatus",
+        "movingMessagesStatus" :
+        "copyingMessagesStatus",
         stringArray, 3, getter_Copies(finalString));
       int64_t nowMS = PR_IntervalToMilliseconds(PR_IntervalNow());
 
       // only update status/progress every half second
       if (nowMS - mCopyState->m_lastProgressTime < 500 &&
           mCopyState->m_curCopyIndex < mCopyState->m_totalMsgCount)
         return NS_OK;
 
--- a/mailnews/local/src/nsMovemailService.cpp
+++ b/mailnews/local/src/nsMovemailService.cpp
@@ -132,20 +132,20 @@ nsMovemailService::Error(const char* err
   nsCOMPtr<nsIStringBundle> bundle;
   rv = bundleService->CreateBundle("chrome://messenger/locale/localMsgs.properties", getter_AddRefs(bundle));
   if (NS_FAILED(rv))
     return;
 
   nsString errStr;
   // Format the error string if necessary
   if (params)
-    bundle->FormatStringFromName(NS_ConvertASCIItoUTF16(errorCode).get(),
+    bundle->FormatStringFromName(errorCode,
                                  params, length, getter_Copies(errStr));
   else
-    bundle->GetStringFromName(NS_ConvertASCIItoUTF16(errorCode).get(),
+    bundle->GetStringFromName(errorCode,
                               getter_Copies(errStr));
 
   if (!errStr.IsEmpty()) {
     dialog->Alert(nullptr, errStr.get());
   }
 }
 
 SpoolLock::SpoolLock(nsACString *aSpoolName, int aSeconds,
--- a/mailnews/local/src/nsParseMailbox.cpp
+++ b/mailnews/local/src/nsParseMailbox.cpp
@@ -289,17 +289,17 @@ void nsMsgMailboxParser::UpdateStatusTex
     if (!bundleService)
       return;
     nsCOMPtr<nsIStringBundle> bundle;
     rv = bundleService->CreateBundle("chrome://messenger/locale/localMsgs.properties", getter_AddRefs(bundle));
     if (NS_FAILED(rv))
       return;
     nsString finalString;
     const char16_t * stringArray[] = { m_folderName.get() };
-    rv = bundle->FormatStringFromName(NS_ConvertASCIItoUTF16(stringName).get(),
+    rv = bundle->FormatStringFromName(stringName,
                                       stringArray, 1, getter_Copies(finalString));
     m_statusFeedback->ShowStatusString(finalString);
   }
 }
 
 void nsMsgMailboxParser::UpdateProgressPercent ()
 {
   if (m_statusFeedback && m_graph_progress_total != 0)
--- a/mailnews/local/src/nsPop3Protocol.cpp
+++ b/mailnews/local/src/nsPop3Protocol.cpp
@@ -647,26 +647,25 @@ nsresult nsPop3Protocol::FormatCounterSt
   nsAutoString count2String;
   count2String.AppendInt(count2);
 
   const char16_t *formatStrings[] = {
     count1String.get(),
     count2String.get()
   };
 
-  return mLocalBundle->FormatStringFromName(stringName.get(),
+  return mLocalBundle->FormatStringFromName(NS_ConvertUTF16toUTF8(stringName).get(),
                                             formatStrings, 2,
                                             getter_Copies(resultString));
 }
 
-void nsPop3Protocol::UpdateStatus(const char16_t *aStatusName)
+void nsPop3Protocol::UpdateStatus(const char *aStatusName)
 {
   nsString statusMessage;
-  mLocalBundle->GetStringFromName(aStatusName,
-                                  getter_Copies(statusMessage));
+  mLocalBundle->GetStringFromName(aStatusName, getter_Copies(statusMessage));
   UpdateStatusWithString(statusMessage.get());
 }
 
 void nsPop3Protocol::UpdateStatusWithString(const char16_t *aStatusString)
 {
     if (mProgressEventSink)
     {
       mozilla::DebugOnly<nsresult> rv =
@@ -887,29 +886,29 @@ NS_IMETHODIMP nsPop3Protocol::OnPromptSt
           // As we're async, calling ProcessProtocolState gets things going
           // again.
           ProcessProtocolState(nullptr, nullptr, 0, 0);
           return NS_OK;
         }
       }
     }
     mLocalBundle->FormatStringFromName(
-      u"pop3PreviouslyEnteredPasswordIsInvalidPrompt",
+      "pop3PreviouslyEnteredPasswordIsInvalidPrompt",
       passwordParams, 2, getter_Copies(passwordPrompt));
   }
   else
     // Otherwise this is the first time we've asked about the server's
     // password so show a first time prompt.
     mLocalBundle->FormatStringFromName(
-      u"pop3EnterPasswordPrompt",
+      "pop3EnterPasswordPrompt",
       passwordParams, 2, getter_Copies(passwordPrompt));
 
   nsString passwordTitle;
   mLocalBundle->GetStringFromName(
-    u"pop3EnterPasswordPromptTitle",
+    "pop3EnterPasswordPromptTitle",
     getter_Copies(passwordTitle));
 
   // Now go and get the password.
   if (!passwordPrompt.IsEmpty() && !passwordTitle.IsEmpty())
     rv = server->GetPasswordWithUI(passwordPrompt, passwordTitle,
                                     msgWindow, passwordResult);
   ClearFlag(POP3_PASSWORD_FAILED|POP3_AUTH_FAILURE);
 
@@ -1323,37 +1322,37 @@ nsPop3Protocol::Error(const char* err_co
     // so print out that error message!
     nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(m_pop3Server);
     nsString accountName;
     nsresult rv = server->GetPrettyName(accountName);
     NS_ENSURE_SUCCESS(rv, -1);
     const char16_t *titleParams[] = { accountName.get() };
     nsString dialogTitle;
     mLocalBundle->FormatStringFromName(
-      u"pop3ErrorDialogTitle",
+      "pop3ErrorDialogTitle",
       titleParams, 1, getter_Copies(dialogTitle));
     nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url, &rv);
     // we handle "pop3TmpDownloadError" earlier...
     if (strcmp(err_code, "pop3TmpDownloadError") && NS_SUCCEEDED(rv))
     {
         nsCOMPtr<nsIMsgWindow> msgWindow;
         nsCOMPtr<nsIPrompt> dialog;
         rv = mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow)); //it is ok to have null msgWindow, for example when biffing
         if (NS_SUCCEEDED(rv) && msgWindow)
         {
             rv = msgWindow->GetPromptDialog(getter_AddRefs(dialog));
             if (NS_SUCCEEDED(rv))
             {
               nsString alertString;
               // Format the alert string if parameter list isn't empty
               if (params)
-                mLocalBundle->FormatStringFromName(NS_ConvertASCIItoUTF16(err_code).get(),
+                mLocalBundle->FormatStringFromName(err_code,
                                                    params, length, getter_Copies(alertString));
               else
-                mLocalBundle->GetStringFromName(NS_ConvertASCIItoUTF16(err_code).get(),
+                mLocalBundle->GetStringFromName(err_code,
                                                 getter_Copies(alertString));
               if (m_pop3ConData->command_succeeded)  //not a server error message
                 dialog->Alert(dialogTitle.get(), alertString.get());
               else
               {
                 nsString serverSaidPrefix;
                 nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(m_pop3Server);
                 nsCString hostName;
@@ -1361,17 +1360,17 @@ nsPop3Protocol::Error(const char* err_co
                 if (server)
                   rv = server->GetRealHostName(hostName);
                 if (NS_SUCCEEDED(rv))
                 {
                   nsAutoString hostStr;
                   CopyASCIItoUTF16(hostName, hostStr);
                   const char16_t *params[] = { hostStr.get() };
                   mLocalBundle->FormatStringFromName(
-                    u"pop3ServerSaid",
+                    "pop3ServerSaid",
                     params, 1, getter_Copies(serverSaidPrefix));
                 }
 
                 nsAutoString message(alertString);
                 message.AppendLiteral(" ");
                 message.Append(serverSaidPrefix);
                 message.AppendLiteral(" ");
                 message.Append(NS_ConvertASCIItoUTF16(m_commandResponse));
@@ -3510,17 +3509,17 @@ nsPop3Protocol::TopResponse(nsIInputStre
   So just go download the whole thing, and warn the user.
 
     Note that the progress bar will not be accurate in this case.
     Oops. #### */
     m_pop3ConData->truncating_cur_msg = false;
 
     nsString statusTemplate;
     mLocalBundle->GetStringFromName(
-      u"pop3ServerDoesNotSupportTopCommand",
+      "pop3ServerDoesNotSupportTopCommand",
       getter_Copies(statusTemplate));
     if (!statusTemplate.IsEmpty())
     {
       nsAutoCString hostName;
       char16_t * statusString = nullptr;
       m_url->GetHost(hostName);
 
       statusString = nsTextFormatter::smprintf(statusTemplate.get(), hostName.get());
@@ -3888,17 +3887,17 @@ nsresult nsPop3Protocol::ProcessProtocol
       status = AuthNtlmResponse();
       break;
 
     case POP3_AUTH_GSSAPI:
       status = AuthGSSAPI();
       break;
 
     case POP3_AUTH_GSSAPI_FIRST:
-      UpdateStatus(u"hostContact");
+      UpdateStatus("hostContact");
       status = AuthGSSAPIResponse(true);
       break;
 
     case POP3_AUTH_GSSAPI_STEP:
       status = AuthGSSAPIResponse(false);
       break;
 
     case POP3_SEND_USERNAME:
@@ -3906,17 +3905,17 @@ nsresult nsPop3Protocol::ProcessProtocol
         status = -1;
       break;
 
     case POP3_OBTAIN_PASSWORD_BEFORE_USERNAME:
       status = -1;
       break;
 
     case POP3_FINISH_OBTAIN_PASSWORD_BEFORE_USERNAME:
-      UpdateStatus(u"hostContact");
+      UpdateStatus("hostContact");
       status = SendUsername();
       break;
 
     case POP3_SEND_PASSWORD:
       if (NS_FAILED(StartGetAsyncPassword(POP3_OBTAIN_PASSWORD_BEFORE_PASSWORD)))
         status = -1;
       break;
 
@@ -4014,17 +4013,17 @@ nsresult nsPop3Protocol::ProcessProtocol
         bug 54116), so instead we put the "no new messages" or
         "retrieved x new messages"
         in the status line.  Unfortunately, this tends to be running
         in a progress pane, so we try to get the real pane and
           show the message there. */
 
           if (m_totalDownloadSize <= 0)
           {
-            UpdateStatus(u"noNewMessages");
+            UpdateStatus("noNewMessages");
             /* There are no new messages.  */
           }
           else
           {
             nsString statusString;
             nsresult rv = FormatCounterString(NS_LITERAL_STRING("receivedMsgs"),
                                               m_pop3ConData->real_new_counter - 1,
                                               m_pop3ConData->really_new_messages,
--- a/mailnews/local/src/nsPop3Protocol.h
+++ b/mailnews/local/src/nsPop3Protocol.h
@@ -294,17 +294,17 @@ private:
   nsCString m_commandResponse;
   nsCString m_GSSAPICache;
 
   // Used for asynchronous password prompts to store the password temporarily.
   nsCString m_passwordResult;
 
   // progress state information
   void UpdateProgressPercent(int64_t totalDone, int64_t total);
-  void UpdateStatus(const char16_t *aStatusName);
+  void UpdateStatus(const char *aStatusName);
   void UpdateStatusWithString(const char16_t *aString);
   nsresult FormatCounterString(const nsString &stringName,
                                uint32_t count1,
                                uint32_t count2,
                                nsString &resultString);
 
   int32_t m_bytesInMsgReceived;
   int64_t m_totalFolderSize;
--- a/mailnews/local/src/nsPop3Service.cpp
+++ b/mailnews/local/src/nsPop3Service.cpp
@@ -461,20 +461,20 @@ void nsPop3Service::AlertServerBusy(nsIM
   NS_ENSURE_SUCCESS_VOID(rv);
   rv = server->GetPrettyName(accountName);
   NS_ENSURE_SUCCESS_VOID(rv);
 
   const char16_t *params[] = { accountName.get() };
   nsString alertString;
   nsString dialogTitle;
   bundle->FormatStringFromName(
-    u"pop3ServerBusy",
+    "pop3ServerBusy",
     params, 1, getter_Copies(alertString));
   bundle->FormatStringFromName(
-    u"pop3ErrorDialogTitle",
+    "pop3ErrorDialogTitle",
     params, 1, getter_Copies(dialogTitle));
   if (!alertString.IsEmpty())
     dialog->Alert(dialogTitle.get(), alertString.get());
 }
 
 NS_IMETHODIMP nsPop3Service::NewChannel(nsIURI *aURI, nsIChannel **_retval)
 {
   return NewChannel2(aURI, nullptr, _retval);
--- a/mailnews/local/src/nsPop3Sink.cpp
+++ b/mailnews/local/src/nsPop3Sink.cpp
@@ -763,17 +763,17 @@ nsresult nsPop3Sink::HandleTempDownloadF
   rv = bundleService->CreateBundle("chrome://messenger/locale/localMsgs.properties", getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
   nsString fromStr, subjectStr, confirmString;
 
   m_newMailParser->m_newMsgHdr->GetMime2DecodedSubject(subjectStr);
   m_newMailParser->m_newMsgHdr->GetMime2DecodedAuthor(fromStr);
   const char16_t *params[] = { fromStr.get(), subjectStr.get() };
   bundle->FormatStringFromName(
-    u"pop3TmpDownloadError",
+    "pop3TmpDownloadError",
     params, 2, getter_Copies(confirmString));
   nsCOMPtr<mozIDOMWindowProxy> parentWindow;
   nsCOMPtr<nsIPromptService> promptService = do_GetService(NS_PROMPTSERVICE_CONTRACTID);
   nsCOMPtr<nsIDocShell> docShell;
   if (msgWindow)
   {
     (void) msgWindow->GetRootDocShell(getter_AddRefs(docShell));
     parentWindow = do_QueryInterface(docShell);
--- a/mailnews/mapi/mapihook/src/msgMapiHook.cpp
+++ b/mailnews/mapi/mapihook/src/msgMapiHook.cpp
@@ -142,49 +142,44 @@ bool nsMapiHook::DisplayLoginDialog(bool
     nsCOMPtr<nsIStringBundle> brandBundle;
     rv = bundleService->CreateBundle(
                     "chrome://branding/locale/brand.properties",
                     getter_AddRefs(brandBundle));
     if (NS_FAILED(rv)) return false;
 
     nsString brandName;
     rv = brandBundle->GetStringFromName(
-                       u"brandFullName",
+                       "brandFullName",
                        getter_Copies(brandName));
     if (NS_FAILED(rv)) return false;
 
     nsString loginTitle;
     const char16_t *brandStrings[] = { brandName.get() };
-    NS_NAMED_LITERAL_STRING(loginTitlePropertyTag, "loginTitle");
-    const char16_t *dTitlePropertyTag = loginTitlePropertyTag.get();
-    rv = bundle->FormatStringFromName(dTitlePropertyTag, brandStrings, 1,
+    rv = bundle->FormatStringFromName("loginTitle", brandStrings, 1,
                                       getter_Copies(loginTitle));
     if (NS_FAILED(rv)) return false;
 
     if (aLogin)
     {
       nsString loginText;
-      rv = bundle->GetStringFromName(u"loginTextwithName",
+      rv = bundle->GetStringFromName("loginTextwithName",
                                      getter_Copies(loginText));
       if (NS_FAILED(rv) || loginText.IsEmpty()) return false;
 
       bool dummyValue = false;
       rv = dlgService->PromptUsernameAndPassword(nullptr, loginTitle.get(),
                                                  loginText.get(), aUsername, aPassword,
                                                  nullptr, &dummyValue, &btnResult);
     }
     else
     {
       //nsString loginString;
       nsString loginText;
       const char16_t *userNameStrings[] = { *aUsername };
-
-      NS_NAMED_LITERAL_STRING(loginTextPropertyTag, "loginText");
-      const char16_t *dpropertyTag = loginTextPropertyTag.get();
-      rv = bundle->FormatStringFromName(dpropertyTag, userNameStrings, 1,
+      rv = bundle->FormatStringFromName("loginText", userNameStrings, 1,
                                         getter_Copies(loginText));
       if (NS_FAILED(rv)) return false;
 
       bool dummyValue = false;
       rv = dlgService->PromptPassword(nullptr, loginTitle.get(), loginText.get(),
                                       aPassword, nullptr, &dummyValue, &btnResult);
     }
   }
@@ -251,23 +246,23 @@ nsMapiHook::IsBlindSendAllowed()
     mozilla::services::GetStringBundleService();
   if (!bundleService) return false;
 
   nsCOMPtr<nsIStringBundle> bundle;
   rv = bundleService->CreateBundle(MAPI_PROPERTIES_CHROME, getter_AddRefs(bundle));
   if (NS_FAILED(rv) || !bundle) return false;
 
   nsString warningMsg;
-  rv = bundle->GetStringFromName(u"mapiBlindSendWarning",
-                                      getter_Copies(warningMsg));
+  rv = bundle->GetStringFromName("mapiBlindSendWarning",
+                                 getter_Copies(warningMsg));
   if (NS_FAILED(rv)) return false;
 
   nsString dontShowAgainMessage;
-  rv = bundle->GetStringFromName(u"mapiBlindSendDontShowAgain",
-                                      getter_Copies(dontShowAgainMessage));
+  rv = bundle->GetStringFromName("mapiBlindSendDontShowAgain",
+                                 getter_Copies(dontShowAgainMessage));
   if (NS_FAILED(rv)) return false;
 
   nsCOMPtr<nsIPromptService> dlgService(do_GetService(NS_PROMPTSERVICE_CONTRACTID, &rv));
   if (NS_FAILED(rv) || !dlgService) return false;
 
   bool continueToWarn = true;
   bool okayToContinue = false;
   dlgService->ConfirmCheck(nullptr, nullptr, warningMsg.get(), dontShowAgainMessage.get(), &continueToWarn, &okayToContinue);
--- a/mailnews/mime/cthandlers/pgpmime/nsPgpMimeProxy.cpp
+++ b/mailnews/mime/cthandlers/pgpmime/nsPgpMimeProxy.cpp
@@ -53,17 +53,17 @@ static void MimePgpe_free (void *);
 
 /* Returns a string describing the location of the part (like "2.5.3").
    This is not a full URL, just a part-number.
  */
 static nsCString determineMimePart(MimeObject* obj);
 
 
 #define PGPMIME_PROPERTIES_URL        "chrome://messenger/locale/pgpmime.properties"
-#define PGPMIME_STR_NOT_SUPPORTED_ID  u"pgpMimeNeedsAddon"
+#define PGPMIME_STR_NOT_SUPPORTED_ID  "pgpMimeNeedsAddon"
 #define PGPMIME_URL_PREF              "mail.pgpmime.addon_url"
 
 static void PgpMimeGetNeedsAddonString(nsCString &aResult)
 {
   aResult.AssignLiteral("???");
 
   nsCOMPtr<nsIStringBundleService> stringBundleService =
     mozilla::services::GetStringBundleService();
--- a/mailnews/mime/emitters/nsMimeBaseEmitter.cpp
+++ b/mailnews/mime/emitters/nsMimeBaseEmitter.cpp
@@ -203,17 +203,17 @@ nsMimeBaseEmitter::MimeGetStringByName(c
       res = sBundleService->CreateBundle(propertyURL, getter_AddRefs(m_headerStringBundle));
     }
   }
 
   if (m_headerStringBundle)
   {
     nsString val;
 
-    res = m_headerStringBundle->GetStringFromName(NS_ConvertASCIItoUTF16(aHeaderName).get(),
+    res = m_headerStringBundle->GetStringFromName(aHeaderName,
                                                   getter_Copies(val));
 
     if (NS_FAILED(res))
       return nullptr;
 
     // Here we need to return a new copy of the string
     // This returns a UTF-8 string so the caller needs to perform a conversion
     // if this is used as UCS-2 (e.g. cannot do nsString(utfStr);
--- a/mailnews/mime/emitters/nsMimeHtmlEmitter.cpp
+++ b/mailnews/mime/emitters/nsMimeHtmlEmitter.cpp
@@ -433,17 +433,17 @@ nsMimeHtmlDisplayEmitter::StartAttachmen
       NS_ENSURE_TRUE(bundleSvc, NS_ERROR_UNEXPECTED);
 
       nsCOMPtr<nsIStringBundle> bundle;
       rv = bundleSvc->CreateBundle("chrome://messenger/locale/messenger.properties",
                                    getter_AddRefs(bundle));
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsString attachmentsHeader;
-      bundle->GetStringFromName(u"attachmentsPrintHeader",
+      bundle->GetStringFromName("attachmentsPrintHeader",
                                 getter_Copies(attachmentsHeader)); 
 
       UtilityWrite("<legend class=\"mimeAttachmentHeaderName\">");
       nsCString escapedName;
       escapedName.Adopt(MsgEscapeHTML(NS_ConvertUTF16toUTF8(attachmentsHeader).get()));
       UtilityWrite(escapedName.get());
       UtilityWrite("</legend>");
     }
--- a/mailnews/mime/src/mimemoz2.cpp
+++ b/mailnews/mime/src/mimemoz2.cpp
@@ -1921,17 +1921,17 @@ MimeGetStringByName(const char16_t *stri
   nsCOMPtr<nsIStringBundleService> stringBundleService =
     do_GetService(NS_STRINGBUNDLE_CONTRACTID);
 
   nsCOMPtr<nsIStringBundle> stringBundle;
   stringBundleService->CreateBundle(MIME_URL, getter_AddRefs(stringBundle));
   if (stringBundle)
   {
     nsString v;
-    if (NS_SUCCEEDED(stringBundle->GetStringFromName(stringName, getter_Copies(v))))
+    if (NS_SUCCEEDED(stringBundle->GetStringFromName(NS_ConvertUTF16toUTF8(stringName).get(), getter_Copies(v))))
       return ToNewUTF8String(v);
   }
 
   return strdup("???");
 }
 
 void
 ResetChannelCharset(MimeObject *obj)
--- a/mailnews/news/src/nsNNTPNewsgroupList.cpp
+++ b/mailnews/news/src/nsNNTPNewsgroupList.cpp
@@ -312,17 +312,17 @@ nsNNTPNewsgroupList::GetRangeOfArtsToDow
     nsCOMPtr<nsIStringBundleService> bundleService =
       mozilla::services::GetStringBundleService();
     NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
 
     nsCOMPtr<nsIStringBundle> bundle;
     rv = bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(bundle));
     NS_ENSURE_SUCCESS(rv, rv);
 
-    rv = bundle->GetStringFromName(u"noNewMessages", getter_Copies(statusString));
+    rv = bundle->GetStringFromName("noNewMessages", getter_Copies(statusString));
     NS_ENSURE_SUCCESS(rv, rv);
 
     SetProgressStatus(statusString.get());
   }
 
   if (maxextra <= 0 || last_possible < first_possible || last_possible < 1)
   {
     *status=0;
@@ -881,17 +881,17 @@ nsNNTPNewsgroupList::FinishXOVERLINE(int
         mozilla::services::GetStringBundleService();
       NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
 
       nsCOMPtr<nsIStringBundle> bundle;
       rv = bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(bundle));
       NS_ENSURE_SUCCESS(rv, rv);
 
       const char16_t *formatStrings[2] = { firstStr.get(), lastStr.get() };
-      rv = bundle->FormatStringFromName(u"downloadingArticles", formatStrings, 2, getter_Copies(statusString));
+      rv = bundle->FormatStringFromName("downloadingArticles", formatStrings, 2, getter_Copies(statusString));
       NS_ENSURE_SUCCESS(rv, rv);
 
       SetProgressStatus(statusString.get());
     }
   }
 
   if (newstatus)
     *newstatus=0;
@@ -1248,17 +1248,17 @@ nsNNTPNewsgroupList::SetProgressStatus(c
       nsString statusMessage;
       nsCOMPtr<nsIStringBundleService> sbs =
         mozilla::services::GetStringBundleService();
       nsCOMPtr<nsIStringBundle> bundle;
       rv = sbs->CreateBundle(MSGS_URL,
                              getter_AddRefs(bundle));
       NS_ENSURE_SUCCESS_VOID(rv);
       const char16_t *params[] = { accountName.get(), aMessage };
-      bundle->FormatStringFromName(u"statusMessage",
+      bundle->FormatStringFromName("statusMessage",
                                    params, 2, getter_Copies(statusMessage));
 
       feedback->ShowStatusString(statusMessage);
     }
   }
 }
 
 void
@@ -1290,24 +1290,24 @@ nsNNTPNewsgroupList::UpdateStatus(bool f
   if (!NS_SUCCEEDED(rv))
     return;
 
   if (filtering)
   {
     NS_ConvertUTF8toUTF16 header(m_filterHeaders[m_currentXHDRIndex]);
     const char16_t *formatStrings[4] = { header.get(),
       numDownloadedStr.get(), totalToDownloadStr.get(), newsgroupName.get() };
-    rv = bundle->FormatStringFromName(u"newNewsgroupFilteringHeaders",
+    rv = bundle->FormatStringFromName("newNewsgroupFilteringHeaders",
       formatStrings, 4, getter_Copies(statusString));
   }
   else
   {
     const char16_t *formatStrings[3] = { numDownloadedStr.get(),
       totalToDownloadStr.get(), newsgroupName.get() };
-    rv = bundle->FormatStringFromName(u"newNewsgroupHeaders",
+    rv = bundle->FormatStringFromName("newNewsgroupHeaders",
       formatStrings, 3, getter_Copies(statusString));
   }
   if (!NS_SUCCEEDED(rv))
     return;
 
   SetProgressStatus(statusString.get());
   m_lastStatusUpdate = PR_Now();
 
--- a/mailnews/news/src/nsNNTPProtocol.cpp
+++ b/mailnews/news/src/nsNNTPProtocol.cpp
@@ -1014,17 +1014,17 @@ nsresult nsNNTPProtocol::LoadUrl(nsIURI 
       nsAutoString unescapedName;
       rv = NS_MsgDecodeUnescapeURLPath(group, unescapedName);
       NS_ENSURE_SUCCESS(rv,rv);
 
       bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(bundle));
       const char16_t *formatStrings[1] = { unescapedName.get() };
 
       rv = bundle->FormatStringFromName(
-        u"autoSubscribeText", formatStrings, 1,
+        "autoSubscribeText", formatStrings, 1,
         getter_Copies(confirmText));
       NS_ENSURE_SUCCESS(rv,rv);
 
       bool confirmResult = false;
       rv = dialog->Confirm(nullptr, confirmText.get(), &confirmResult);
       NS_ENSURE_SUCCESS(rv, rv);
 
       if (confirmResult)
@@ -2806,17 +2806,17 @@ nsresult nsNNTPProtocol::ReadNewsList(ns
       char rate_buf[RATE_STR_BUF_LEN];
       PR_snprintf(rate_buf,RATE_STR_BUF_LEN,"%.1f", rate);
 
       nsAutoString numGroupsStr;
       numGroupsStr.AppendInt(mNumGroupsListed);
       NS_ConvertASCIItoUTF16 rateStr(rate_buf);
 
       const char16_t *formatStrings[3] = { numGroupsStr.get(), bytesStr.get(), rateStr.get()};
-      rv = bundle->FormatStringFromName(u"bytesReceived",
+      rv = bundle->FormatStringFromName("bytesReceived",
         formatStrings, 3,
         getter_Copies(statusString));
 
       rv = msgStatusFeedback->ShowStatusString(statusString);
       if (NS_FAILED(rv)) {
         PR_Free(lineToFree);
         return rv;
       }
@@ -3410,21 +3410,18 @@ nsresult nsNNTPProtocol::GetNewsStringBy
     NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
 
     rv = bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(m_stringBundle));
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   if (m_stringBundle)
   {
-    nsAutoString unicodeName;
-    CopyASCIItoUTF16(nsDependentCString(aName), unicodeName);
-
     char16_t *ptrv = nullptr;
-    rv = m_stringBundle->GetStringFromName(unicodeName.get(), &ptrv);
+    rv = m_stringBundle->GetStringFromName(aName, &ptrv);
 
     if (NS_FAILED(rv))
     {
       resultString.AssignLiteral("[StringName");
       resultString.Append(NS_ConvertASCIItoUTF16(aName));
       resultString.AppendLiteral("?]");
       *aString = ToNewUnicode(resultString);
     }
@@ -3578,17 +3575,17 @@ nsresult nsNNTPProtocol::DoCancel()
   NS_ENSURE_TRUE(bundleService, NS_ERROR_OUT_OF_MEMORY);
 
   nsCOMPtr<nsIStringBundle> brandBundle;
   bundleService->CreateBundle("chrome://branding/locale/brand.properties",
                               getter_AddRefs(brandBundle));
   NS_ENSURE_TRUE(brandBundle, NS_ERROR_FAILURE);
 
   nsString brandFullName;
-  rv = brandBundle->GetStringFromName(u"brandFullName",
+  rv = brandBundle->GetStringFromName("brandFullName",
                                       getter_Copies(brandFullName));
   NS_ENSURE_SUCCESS(rv,rv);
   NS_ConvertUTF16toUTF8 appName(brandFullName);
 
   newsgroups = m_cancelNewsgroups;
   distribution = m_cancelDistribution;
   id = m_cancelID;
   nsCString oldFrom(m_cancelFromHdr);
--- a/mailnews/news/src/nsNewsDownloader.cpp
+++ b/mailnews/news/src/nsNewsDownloader.cpp
@@ -192,17 +192,17 @@ bool nsNewsDownloader::GetNextHdrToRetri
     nsAutoString totalStr;
     totalStr.AppendInt(int(m_keysToDownload.Length()));
     nsString prettyName;
     nsString statusString;
 
     m_folder->GetPrettyName(prettyName);
 
     const char16_t *formatStrings[3] = { firstStr.get(), totalStr.get(), prettyName.get() };
-    rv = bundle->FormatStringFromName(u"downloadingArticlesForOffline",
+    rv = bundle->FormatStringFromName("downloadingArticlesForOffline",
                                       formatStrings, 3, getter_Copies(statusString));
     NS_ENSURE_SUCCESS(rv, false);
     ShowProgress(statusString.get(), percent);
     return true;
   }
   NS_ASSERTION(false, "shouldn't get here if we're not downloading from keys.");
   return false;  // shouldn't get here if we're not downloading from keys.
 }
--- a/mailnews/news/src/nsNewsFolder.cpp
+++ b/mailnews/news/src/nsNewsFolder.cpp
@@ -1231,17 +1231,17 @@ nsMsgNewsFolder::GetAuthenticationCreden
       if (!dialog) return NS_ERROR_FAILURE;
     }
 
     NS_ASSERTION(dialog, "We didn't get a net prompt");
     if (dialog)
     {
       // Format the prompt text strings
       nsString promptTitle, promptText;
-      bundle->GetStringFromName(u"enterUserPassTitle",
+      bundle->GetStringFromName("enterUserPassTitle",
         getter_Copies(promptTitle));
 
       nsString serverName;
       nsCOMPtr<nsIMsgIncomingServer> server;
       rv = GetServer(getter_AddRefs(server));
       NS_ENSURE_SUCCESS(rv, rv);
 
       server->GetPrettyName(serverName);
@@ -1253,21 +1253,21 @@ nsMsgNewsFolder::GetAuthenticationCreden
       bool singleSignon = true;
       nntpServer->GetSingleSignon(&singleSignon);
 
       const char16_t *params[2];
       params[0] = mName.get();
       params[1] = serverName.get();
       if (singleSignon)
         bundle->FormatStringFromName(
-          u"enterUserPassServer",
+          "enterUserPassServer",
           &params[1], 1, getter_Copies(promptText));
       else
         bundle->FormatStringFromName(
-          u"enterUserPassGroup",
+          "enterUserPassGroup",
           params, 2, getter_Copies(promptText));
 
       // Fill the signon url for the dialog
       nsString signonURL;
       rv = CreateNewsgroupUrlForSignon(nullptr, signonURL);
       NS_ENSURE_SUCCESS(rv, rv);
 
       // Prefill saved username/password
--- a/mailnews/news/src/nsNntpIncomingServer.cpp
+++ b/mailnews/news/src/nsNntpIncomingServer.cpp
@@ -1575,17 +1575,17 @@ nsNntpIncomingServer::GroupNotFound(nsIM
   NS_ENSURE_SUCCESS(rv,rv);
 
   NS_ConvertUTF8toUTF16 hostStr(hostname);
 
   nsString groupName(aName);
   const char16_t *formatStrings[2] = { groupName.get(), hostStr.get() };
   nsString confirmText;
   rv = bundle->FormatStringFromName(
-                    u"autoUnsubscribeText",
+                    "autoUnsubscribeText",
                     formatStrings, 2,
                     getter_Copies(confirmText));
   NS_ENSURE_SUCCESS(rv,rv);
 
   bool confirmResult = false;
   rv = prompt->Confirm(nullptr, confirmText.get(), &confirmResult);
   NS_ENSURE_SUCCESS(rv,rv);
 
--- a/suite/shell/src/nsGNOMEShellService.cpp
+++ b/suite/shell/src/nsGNOMEShellService.cpp
@@ -89,17 +89,17 @@ GetBrandName(nsACString& aBrandName)
   nsCOMPtr<nsIStringBundleService> bundleService(do_GetService("@mozilla.org/intl/stringbundle;1", &rv));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIStringBundle> brandBundle;
   rv = bundleService->CreateBundle(BRAND_PROPERTIES, getter_AddRefs(brandBundle));
   NS_ENSURE_TRUE(brandBundle, rv);
 
   nsString brandName;
-  rv = brandBundle->GetStringFromName(u"brandShortName",
+  rv = brandBundle->GetStringFromName("brandShortName",
                                       getter_Copies(brandName));
   NS_ENSURE_SUCCESS(rv, rv);
 
   CopyUTF16toUTF8(brandName, aBrandName);
   return rv;
 }
 
 nsresult
--- a/suite/shell/src/nsWindowsShellService.cpp
+++ b/suite/shell/src/nsWindowsShellService.cpp
@@ -776,17 +776,17 @@ nsWindowsShellService::SetDesktopBackgro
   nsCOMPtr<nsIStringBundle> shellBundle;
   rv = bundleService->CreateBundle(SHELLSERVICE_PROPERTIES,
                                    getter_AddRefs(shellBundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // e.g. "Desktop Background.bmp"
   nsString fileLeafName;
   rv = shellBundle->GetStringFromName
-                      (u"desktopBackgroundLeafNameWin",
+                      ("desktopBackgroundLeafNameWin",
                        getter_Copies(fileLeafName));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // get the profile root directory
   nsCOMPtr<nsIFile> file;
   rv = NS_GetSpecialDirectory(NS_APP_APPLICATION_REGISTRY_DIR,
                               getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);