Bug 1288355 - Replace MOZ_UTF16("xxx") with u"xxx". r=bustage-fix a=jorgk CLOSED TREE
authorJorg K <mozilla@jorgk.com>
Fri, 22 Jul 2016 01:15:55 +0200
changeset 19602 a09c05db1261adcd776d53aac2681b655ed0c401
parent 19601 dd8fa7b8bd6578ac68ca36c7b93dbc9ab3b7cef7
child 19603 66ffb3c065761c381f925728f30d42462a15a77c
push id12094
push usermozilla@jorgk.com
push dateThu, 21 Jul 2016 23:16:42 +0000
treeherdercomm-central@a09c05db1261 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbustage-fix, jorgk
bugs1288355
Bug 1288355 - Replace MOZ_UTF16("xxx") with u"xxx". r=bustage-fix a=jorgk CLOSED TREE
mail/components/shell/nsMailGNOMEIntegration.cpp
mailnews/addrbook/src/nsAbCardProperty.cpp
mailnews/addrbook/src/nsAbLDAPChangeLogData.cpp
mailnews/addrbook/src/nsAbLDAPDirectory.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/search/src/nsMsgSearchAdapter.cpp
mailnews/base/src/nsMessenger.cpp
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/nsMsgGroupView.cpp
mailnews/base/src/nsMsgPrintEngine.cpp
mailnews/base/src/nsMsgStatusFeedback.cpp
mailnews/base/src/nsMsgWindow.cpp
mailnews/base/src/nsSpamSettings.cpp
mailnews/base/src/nsSubscribableServer.cpp
mailnews/base/src/nsSubscribeDataSource.cpp
mailnews/base/util/nsMsgDBFolder.cpp
mailnews/base/util/nsMsgI18N.cpp
mailnews/base/util/nsMsgIncomingServer.cpp
mailnews/base/util/nsMsgProtocol.cpp
mailnews/base/util/nsMsgUtils.cpp
mailnews/compose/src/nsComposeStrings.cpp
mailnews/compose/src/nsMsgAttachmentHandler.cpp
mailnews/compose/src/nsMsgCompUtils.cpp
mailnews/compose/src/nsMsgCompose.cpp
mailnews/compose/src/nsMsgComposeService.cpp
mailnews/compose/src/nsMsgPrompts.cpp
mailnews/compose/src/nsMsgSend.cpp
mailnews/compose/src/nsMsgSendLater.cpp
mailnews/compose/src/nsMsgSendReport.cpp
mailnews/compose/src/nsSmtpProtocol.cpp
mailnews/extensions/mailviews/src/nsMsgMailViewList.cpp
mailnews/extensions/mdn/src/nsMsgMdnGenerator.cpp
mailnews/extensions/smime/src/nsMsgComposeSecure.cpp
mailnews/imap/src/nsImapIncomingServer.cpp
mailnews/imap/src/nsImapMailFolder.cpp
mailnews/imap/src/nsImapProtocol.cpp
mailnews/imap/src/nsImapService.cpp
mailnews/import/applemail/src/nsAppleMailImport.cpp
mailnews/import/becky/src/nsBeckyAddressBooks.cpp
mailnews/import/becky/src/nsBeckyFilters.cpp
mailnews/import/becky/src/nsBeckyImport.cpp
mailnews/import/becky/src/nsBeckyMail.cpp
mailnews/import/becky/src/nsBeckySettings.cpp
mailnews/import/outlook/src/nsOutlookCompose.cpp
mailnews/import/src/nsImportMail.cpp
mailnews/intl/nsCharsetConverterManager.cpp
mailnews/local/src/nsLocalMailFolder.cpp
mailnews/local/src/nsPop3Protocol.cpp
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/mimemsg.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(MOZ_UTF16("brandShortName"),
+    brandBundle->GetStringFromName(u"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
@@ -676,29 +676,29 @@ nsresult nsAbCardProperty::ConvertToEsca
     if (NS_SUCCEEDED(rv) && !str.IsEmpty())
     {
         myAddPropValue(vObj, VCNoteProp, str.get(), &vCardHasData);
     }
 
     uint32_t format;
     rv = GetPropertyAsUint32(kPreferMailFormatProperty, &format);
     if (NS_SUCCEEDED(rv) && format == nsIAbPreferMailFormat::html) {
-        myAddPropValue(vObj, VCUseHTML, MOZ_UTF16("TRUE"), &vCardHasData);
+        myAddPropValue(vObj, VCUseHTML, u"TRUE", &vCardHasData);
     }
     else if (NS_SUCCEEDED(rv) && format == nsIAbPreferMailFormat::plaintext) {
-        myAddPropValue(vObj, VCUseHTML, MOZ_UTF16("FALSE"), &vCardHasData);
+        myAddPropValue(vObj, VCUseHTML, u"FALSE", &vCardHasData);
     }
 
     rv = GetPropertyAsAString(kWorkWebPageProperty, str);
     if (NS_SUCCEEDED(rv) && !str.IsEmpty())
     {
         myAddPropValue(vObj, VCURLProp, str.get(), &vCardHasData);
     }
 
-    myAddPropValue(vObj, VCVersionProp, MOZ_UTF16("2.1"), nullptr);
+    myAddPropValue(vObj, VCVersionProp, u"2.1", nullptr);
 
     if (!vCardHasData) {
         aResult.Truncate();
         cleanVObject(vObj);
         return NS_OK;
     }
 
     int len = 0;
@@ -724,17 +724,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(MOZ_UTF16("addressBook"), getter_Copies(addrBook));
+      rv = bundle->GetStringFromName(u"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");
       }
     }
   }
 
@@ -816,17 +816,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(MOZ_UTF16("headingAddresses"), getter_Copies(headingAddresses));
+    rv = bundle->GetStringFromName(u"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);
 
@@ -1038,28 +1038,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(MOZ_UTF16("cityAndStateAndZip"), formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
+    rv = aBundle->FormatStringFromName(u"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(MOZ_UTF16("cityAndStateNoZip"), formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
+    rv = aBundle->FormatStringFromName(u"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(MOZ_UTF16("cityOrStateAndZip"), formatStrings, ArrayLength(formatStrings), getter_Copies(formattedString));
+    rv = aBundle->FormatStringFromName(u"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
@@ -1103,23 +1103,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(MOZ_UTF16("lastFirstFormat"),
+      rv = bundle->FormatStringFromName(u"lastFirstFormat",
                                         stringParams, 2, getter_Copies(result));
     }
     else {
       const char16_t *stringParams[2] = {firstName.get(), lastName.get()};
 
-      rv = bundle->FormatStringFromName(MOZ_UTF16("firstLastFormat"),
+      rv = bundle->FormatStringFromName(u"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(MOZ_UTF16("AuthDlgTitle"), getter_Copies(title));
+    rv = bundle->GetStringFromName(u"AuthDlgTitle", getter_Copies(title));
     if (NS_FAILED (rv)) 
         return rv ;
 
     nsString desc;
-    rv = bundle->GetStringFromName(MOZ_UTF16("AuthDlgDesc"), getter_Copies(desc));
+    rv = bundle->GetStringFromName(u"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/nsAbLDAPDirectory.cpp
+++ b/mailnews/addrbook/src/nsAbLDAPDirectory.cpp
@@ -251,18 +251,18 @@ NS_IMETHODIMP nsAbLDAPDirectory::SetLDAP
   {
     // They don't so its time to send round an update.
     nsCOMPtr<nsIAbManager> abManager = do_GetService(NS_ABMANAGER_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
 
     // We inherit from nsIAbDirectory, so this static cast should be safe.
     abManager->NotifyItemPropertyChanged(static_cast<nsIAbDirectory*>(this),
       "IsSecure",
-      (newIsNotSecure ? MOZ_UTF16("true") : MOZ_UTF16("false")),
-      (newIsNotSecure ? MOZ_UTF16("false") : MOZ_UTF16("true")));
+      (newIsNotSecure ? u"true" : u"false"),
+      (newIsNotSecure ? u"false" : u"true"));
   }
 
   return NS_OK;
 }
 
 /* 
  *
  * nsIAbDirectorySearch methods
--- 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(MOZ_UTF16("authPromptTitle"),
+    rv = ldapBundle->GetStringFromName(u"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(MOZ_UTF16("authPromptText"),
+    rv = ldapBundle->FormatStringFromName(u"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
@@ -545,51 +545,51 @@ 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(MOZ_UTF16("ExportAddressBookNameTitle"), formatStrings,
+  rv = bundle->FormatStringFromName(u"ExportAddressBookNameTitle", formatStrings,
                                     ArrayLength(formatStrings), getter_Copies(title));
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = filePicker->Init(aParentWin, title, nsIFilePicker::modeSave);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString filterString;
 
   // CSV: System charset and UTF-8.
-  rv = bundle->GetStringFromName(MOZ_UTF16("CSVFilesSysCharset"), getter_Copies(filterString));
+  rv = bundle->GetStringFromName(u"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(MOZ_UTF16("CSVFilesUTF8"), getter_Copies(filterString));
+  rv = bundle->GetStringFromName(u"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(MOZ_UTF16("TABFilesSysCharset"), getter_Copies(filterString));
+  rv = bundle->GetStringFromName(u"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(MOZ_UTF16("TABFilesUTF8"), getter_Copies(filterString));
+  rv = bundle->GetStringFromName(u"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(MOZ_UTF16("VCFFiles"), getter_Copies(filterString));
+  rv = bundle->GetStringFromName(u"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(MOZ_UTF16("LDIFFiles"), getter_Copies(filterString));
+  rv = bundle->GetStringFromName(u"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
@@ -470,17 +470,17 @@ nsresult nsAbView::GetCardValue(nsIAbCar
   // else, standard column (like PrimaryEmail and _AimScreenName)
   if (colID[0] == char16_t('G'))
     return card->GenerateName(mGeneratedNameFormat, mABBundle, _retval);
 
   if (colID[0] == char16_t('_') && colID[1] == char16_t('P'))
     // Use LN/FN order for the phonetic name
     return card->GeneratePhoneticName(true, _retval);
 
-  if (!NS_strcmp(colID, MOZ_UTF16("ChatName")))
+  if (!NS_strcmp(colID, u"ChatName"))
     return card->GenerateChatName(_retval);
 
   nsresult rv = card->GetPropertyAsAString(NS_ConvertUTF16toUTF8(colID).get(), _retval);
   if (rv == NS_ERROR_NOT_AVAILABLE) {
     rv = NS_OK;
     _retval.Truncate();
   }
   return rv;
@@ -659,17 +659,17 @@ inplaceSortCallback(const AbCard *card1,
       return closure->abView->CompareCollationKeys(card1->secondaryCollationKey,card1->secondaryCollationKeyLen,card2->secondaryCollationKey,card2->secondaryCollationKeyLen) * (closure->factor);
   }
 }
 
 static void SetSortClosure(const char16_t *sortColumn, const char16_t *sortDirection, nsAbView *abView, SortClosure *closure)
 {
   closure->colID = sortColumn;
   
-  if (sortDirection && !NS_strcmp(sortDirection, MOZ_UTF16("descending")))
+  if (sortDirection && !NS_strcmp(sortDirection, u"descending"))
     closure->factor = DESCENDING_SORT_FACTOR;
   else 
     closure->factor = ASCENDING_SORT_FACTOR;
 
   closure->abView = abView;
   return;
 }
 
@@ -1314,18 +1314,18 @@ NS_IMETHODIMP nsAbView::SwapFirstNameLas
           {
             nsString dnLnFn;
             nsString dnFnLn;
             const char16_t *nameString[2];
             const char16_t *formatString;
 
             // The format should stays the same before/after we swap the names
             formatString = displayNameLastnamefirst ?
-                              MOZ_UTF16("lastFirstFormat") :
-                              MOZ_UTF16("firstLastFormat");
+                              u"lastFirstFormat" :
+                              u"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
@@ -274,17 +274,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(MOZ_UTF16("addressBook"), getter_Copies(addrBook));
+      rv = bundle->GetStringFromName(u"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
@@ -424,25 +424,25 @@ nsresult nsAddrDatabase::DisplayAlert(co
   NS_ENSURE_SUCCESS(rv, rv);
 
   return prompter->Alert(nullptr /* we don't know the parent window */, alertTitle.get(), alertMessage.get());
 }
 
 nsresult nsAddrDatabase::AlertAboutCorruptMabFile(const char16_t *aOldFileName, const char16_t *aNewFileName)
 {
   const char16_t *formatStrings[] = { aOldFileName, aOldFileName, aNewFileName };
-  return DisplayAlert(MOZ_UTF16("corruptMabFileTitle"),
-    MOZ_UTF16("corruptMabFileAlert"), formatStrings, 3);
+  return DisplayAlert(u"corruptMabFileTitle",
+    u"corruptMabFileAlert", formatStrings, 3);
 }
 
 nsresult nsAddrDatabase::AlertAboutLockedMabFile(const char16_t *aFileName)
 {
   const char16_t *formatStrings[] = { aFileName };
-  return DisplayAlert(MOZ_UTF16("lockedMabFileTitle"),
-    MOZ_UTF16("lockedMabFileAlert"), formatStrings, 1);
+  return DisplayAlert(u"lockedMabFileTitle",
+    u"lockedMabFileAlert", formatStrings, 1);
 }
 
 nsresult
 nsAddrDatabase::OpenInternal(nsIFile *aMabFile, bool aCreate, nsIAddrDatabase** pAddrDB)
 {
   nsAddrDatabase *pAddressBookDB = new nsAddrDatabase();
   if (!pAddressBookDB) {
     return NS_ERROR_OUT_OF_MEMORY;
--- a/mailnews/base/search/src/nsMsgFilter.cpp
+++ b/mailnews/base/search/src/nsMsgFilter.cpp
@@ -581,28 +581,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(
-                      MOZ_UTF16("filterFailureWarningPrefix"),
+                      u"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(
-      MOZ_UTF16("filterLogDetectStr"),
+      u"filterLogDetectStr",
       filterLogDetectFormatStrings, 4,
       getter_Copies(filterLogDetectStr));
     NS_ENSURE_SUCCESS(rv, rv);
 
     buffer += NS_ConvertUTF16toUTF8(filterLogDetectStr);
     buffer +=  "\n";
 
     if (actionType == nsMsgFilterAction::MoveToFolder ||
@@ -615,33 +615,33 @@ 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) ?
-          MOZ_UTF16("logMoveStr") : MOZ_UTF16("logCopyStr"),
+          u"logMoveStr" : u"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(
-                  MOZ_UTF16("filterMissingCustomAction"),
+                  u"filterMissingCustomAction",
                   getter_Copies(filterActionName));
       buffer += NS_ConvertUTF16toUTF8(filterActionName);
     }
     else
     {
       nsString actionValue;
       nsAutoString filterActionID;
       filterActionID = NS_LITERAL_STRING("filterAction");
--- a/mailnews/base/search/src/nsMsgFilterService.cpp
+++ b/mailnews/base/search/src/nsMsgFilterService.cpp
@@ -1175,17 +1175,17 @@ bool nsMsgFilterAfterTheFact::ContinueEx
   nsString filterName;
   m_curFilter->GetFilterName(filterName);
   nsString formatString;
   nsString confirmText;
   const char16_t *formatStrings[] =
   {
     filterName.get()
   };
-  nsresult rv = bundle->FormatStringFromName(MOZ_UTF16("continueFilterExecution"),
+  nsresult rv = bundle->FormatStringFromName(u"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/search/src/nsMsgSearchAdapter.cpp
+++ b/mailnews/base/search/src/nsMsgSearchAdapter.cpp
@@ -149,17 +149,17 @@ NS_IMETHODIMP nsMsgSearchAdapter::AddHit
 
 
 char *
 nsMsgSearchAdapter::GetImapCharsetParam(const char16_t *destCharset)
 {
   char *result = nullptr;
 
   // Specify a character set unless we happen to be US-ASCII.
-  if (NS_strcmp(destCharset, MOZ_UTF16("us-ascii")))
+  if (NS_strcmp(destCharset, u"us-ascii"))
       result = PR_smprintf("%s%s", nsMsgSearchAdapter::m_kImapCharset, NS_ConvertUTF16toUTF8(destCharset).get());
 
   return result;
 }
 
 /*
    09/21/2000 - taka@netscape.com
    This method is bogus. Escape must be done against char * not char16_t *
--- a/mailnews/base/src/nsMessenger.cpp
+++ b/mailnews/base/src/nsMessenger.cpp
@@ -248,17 +248,17 @@ NS_IMETHODIMP nsMessenger::SetWindow(moz
     nsIDocShell *docShell = win->GetDocShell();
     nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(docShell));
     NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
 
     nsCOMPtr<nsIDocShellTreeItem> rootDocShellAsItem;
     docShellAsItem->GetSameTypeRootTreeItem(getter_AddRefs(rootDocShellAsItem));
 
     nsCOMPtr<nsIDocShellTreeItem> childAsItem;
-    rv = rootDocShellAsItem->FindChildWithName(MOZ_UTF16("messagepane"), true, false,
+    rv = rootDocShellAsItem->FindChildWithName(u"messagepane", true, false,
                                                nullptr, nullptr, getter_AddRefs(childAsItem));
 
     mDocShell = do_QueryInterface(childAsItem);
     if (NS_SUCCEEDED(rv) && mDocShell) {
       mCurrentDisplayCharset = ""; // Important! Clear out mCurrentDisplayCharset so we reset a default charset on mDocshell the next time we try to load something into it.
 
       if (aMsgWindow)
         aMsgWindow->GetTransactionManager(getter_AddRefs(mTxnMgr));
@@ -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(MOZ_UTF16("fileExists"),
+    rv = mStringBundle->FormatStringFromName(u"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)
     {
@@ -832,17 +832,17 @@ nsMessenger::SaveOneAttachment(const cha
     {
       rv = InitStringBundle();
       NS_ENSURE_SUCCESS(rv, rv);
     }
 
     nsString filterName;
     const char16_t *extensionParam[] = { extension.get() };
     rv = mStringBundle->FormatStringFromName(
-      MOZ_UTF16("saveAsType"), extensionParam, 1, getter_Copies(filterName));
+      u"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);
 
@@ -3048,17 +3048,17 @@ nsMessenger::PromptIfDeleteAttachments(b
     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 ?
-    MOZ_UTF16("detachAttachments") : MOZ_UTF16("deleteAttachments");
+    u"detachAttachments" : u"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/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 ?
-                                  MOZ_UTF16("newMailNotification_message") :
-                                  MOZ_UTF16("newMailNotification_messages"),
+                                  u"newMailNotification_message" :
+                                  u"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(MOZ_UTF16("newMailNotification_messagetitle"),
+    aBundle->FormatStringFromName(u"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
@@ -730,19 +730,19 @@ void nsMessengerWinIntegration::FillTool
 
         const char16_t *formatStrings[] =
         {
           numNewMsgsText.get(),
         };
 
         nsString finalText;
         if (numNewMessages == 1)
-          bundle->FormatStringFromName(MOZ_UTF16("biffNotification_message"), formatStrings, 1, getter_Copies(finalText));
+          bundle->FormatStringFromName(u"biffNotification_message", formatStrings, 1, getter_Copies(finalText));
         else
-          bundle->FormatStringFromName(MOZ_UTF16("biffNotification_messages"), formatStrings, 1, getter_Copies(finalText));
+          bundle->FormatStringFromName(u"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
@@ -2294,17 +2294,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(MOZ_UTF16("localFolders"), getter_Copies(localFoldersName));
+  return bundle->GetStringFromName(u"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
@@ -149,17 +149,17 @@ nsMsgAccountManagerDataSource::nsMsgAcco
     getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_SMTP),
                                  &kNC_PageTitleSMTP);
     getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_JUNK),
                                  &kNC_PageTitleJunk);
 
     getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_ACCOUNTROOT),
                                  &kNC_AccountRoot);
 
-    getRDFService()->GetLiteral(MOZ_UTF16("true"),
+    getRDFService()->GetLiteral(u"true",
                                 &kTrueLiteral);
 
     // eventually these need to exist in some kind of array
     // that's easily extensible
     getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_SETTINGS), &kNC_Settings);
 
     kDefaultServerAtom = MsgNewAtom("DefaultServer").take();
   }
@@ -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(MOZ_UTF16("prefPanel-server"),
+      mStringBundle->GetStringFromName(u"prefPanel-server",
                                        getter_Copies(pageTitle));
 
     else if (source == kNC_PageTitleCopies)
-      mStringBundle->GetStringFromName(MOZ_UTF16("prefPanel-copies"),
+      mStringBundle->GetStringFromName(u"prefPanel-copies",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleSynchronization)
-      mStringBundle->GetStringFromName(MOZ_UTF16("prefPanel-synchronization"),
+      mStringBundle->GetStringFromName(u"prefPanel-synchronization",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleDiskSpace)
-      mStringBundle->GetStringFromName(MOZ_UTF16("prefPanel-diskspace"),
+      mStringBundle->GetStringFromName(u"prefPanel-diskspace",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleAddressing)
-      mStringBundle->GetStringFromName(MOZ_UTF16("prefPanel-addressing"),
+      mStringBundle->GetStringFromName(u"prefPanel-addressing",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleSMTP)
-      mStringBundle->GetStringFromName(MOZ_UTF16("prefPanel-smtp"),
+      mStringBundle->GetStringFromName(u"prefPanel-smtp",
                                        getter_Copies(pageTitle));
     else if (source == kNC_PageTitleJunk)
-      mStringBundle->GetStringFromName(MOZ_UTF16("prefPanel-junk"),
+      mStringBundle->GetStringFromName(u"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);
--- a/mailnews/base/src/nsMsgDBView.cpp
+++ b/mailnews/base/src/nsMsgDBView.cpp
@@ -152,26 +152,26 @@ nsMsgDBView::nsMsgDBView()
 }
 
 void nsMsgDBView::InitializeAtomsAndLiterals()
 {
   kJunkMsgAtom = MsgNewAtom("junk").take();
   kNotJunkMsgAtom = MsgNewAtom("notjunk").take();
 
   // priority strings
-  kHighestPriorityString = GetString(MOZ_UTF16("priorityHighest"));
-  kHighPriorityString = GetString(MOZ_UTF16("priorityHigh"));
-  kLowestPriorityString = GetString(MOZ_UTF16("priorityLowest"));
-  kLowPriorityString = GetString(MOZ_UTF16("priorityLow"));
-  kNormalPriorityString = GetString(MOZ_UTF16("priorityNormal"));
-
-  kReadString = GetString(MOZ_UTF16("read"));
-  kRepliedString = GetString(MOZ_UTF16("replied"));
-  kForwardedString = GetString(MOZ_UTF16("forwarded"));
-  kNewString = GetString(MOZ_UTF16("new"));
+  kHighestPriorityString = GetString(u"priorityHighest");
+  kHighPriorityString = GetString(u"priorityHigh");
+  kLowestPriorityString = GetString(u"priorityLowest");
+  kLowPriorityString = GetString(u"priorityLow");
+  kNormalPriorityString = GetString(u"priorityNormal");
+
+  kReadString = GetString(u"read");
+  kRepliedString = GetString(u"replied");
+  kForwardedString = GetString(u"forwarded");
+  kNewString = GetString(u"new");
 }
 
 nsMsgDBView::~nsMsgDBView()
 {
   if (m_db)
     m_db->RemoveListener(this);
 
   gInstanceCount--;
@@ -1725,24 +1725,24 @@ NS_IMETHODIMP nsMsgDBView::GetCellValue(
   aValue.Truncate();
   // provide a string "value" for cells that do not normally have text.
   // use empty string for the normal states "Read", "Not Starred", "No Attachment" and "Not Junk"
   switch (colID[0])
   {
     case 'a': // attachment column
       if (flags & nsMsgMessageFlags::Attachment) {
         nsString tmp_str;
-        tmp_str.Adopt(GetString(MOZ_UTF16("messageHasAttachment")));
+        tmp_str.Adopt(GetString(u"messageHasAttachment"));
         aValue.Assign(tmp_str);
       }
       break;
     case 'f': // flagged (starred) column
       if (flags & nsMsgMessageFlags::Marked) {
         nsString tmp_str;
-        tmp_str.Adopt(GetString(MOZ_UTF16("messageHasFlag")));
+        tmp_str.Adopt(GetString(u"messageHasFlag"));
         aValue.Assign(tmp_str);
       }
       break;
     case 'j': // junk column
       if (JunkControlsEnabled(aRow))
       {
         nsCString junkScoreStr;
         msgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
@@ -1764,27 +1764,27 @@ NS_IMETHODIMP nsMsgDBView::GetCellValue(
         {
           IsContainerEmpty(aRow, &isContainerEmpty);
           if (!isContainerEmpty)
           {
             nsString tmp_str;
 
             IsContainerOpen(aRow, &isContainerOpen);
             tmp_str.Adopt(GetString(isContainerOpen ?
-                            MOZ_UTF16("messageExpanded") :
-                            MOZ_UTF16("messageCollapsed")));
+                            u"messageExpanded" :
+                            u"messageCollapsed"));
             aValue.Assign(tmp_str);
           }
         }
       }
       break;
     case 'u': // read/unread column
       if (!(flags & nsMsgMessageFlags::Read)) {
         nsString tmp_str;
-        tmp_str.Adopt(GetString(MOZ_UTF16("messageUnread")));
+        tmp_str.Adopt(GetString(u"messageUnread"));
         aValue.Assign(tmp_str);
       }
       break;
     default:
       aValue.Assign(colID);
       break;
   }
   return rv;
@@ -3225,19 +3225,19 @@ nsresult nsMsgDBView::DeleteMessages(nsI
     NS_ENSURE_SUCCESS(rv, rv);
     bool dontAsk = false; // "Don't ask..." - unchecked by default.
     int32_t buttonPressed = 0;
 
     nsString dialogTitle;
     nsString confirmString;
     nsString checkboxText;
     nsString buttonApplyNowText;
-    dialogTitle.Adopt(GetString(MOZ_UTF16("confirmMsgDelete.title")));
-    checkboxText.Adopt(GetString(MOZ_UTF16("confirmMsgDelete.dontAsk.label")));
-    buttonApplyNowText.Adopt(GetString(MOZ_UTF16("confirmMsgDelete.delete.label")));
+    dialogTitle.Adopt(GetString(u"confirmMsgDelete.title"));
+    checkboxText.Adopt(GetString(u"confirmMsgDelete.dontAsk.label"));
+    buttonApplyNowText.Adopt(GetString(u"confirmMsgDelete.delete.label"));
 
     confirmString.Adopt(GetString(warningName.get()));
 
     const uint32_t buttonFlags =
       (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_0) +
       (nsIPrompt::BUTTON_TITLE_CANCEL * nsIPrompt::BUTTON_POS_1);
     rv = dialog->ConfirmEx(dialogTitle.get(), confirmString.get(), buttonFlags,
                            buttonApplyNowText.get(), nullptr, nullptr,
--- a/mailnews/base/src/nsMsgFolderCompactor.cpp
+++ b/mailnews/base/src/nsMsgFolderCompactor.cpp
@@ -656,17 +656,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(MOZ_UTF16("compactingDone"),
+    rv = bundle->FormatStringFromName(u"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
@@ -276,19 +276,19 @@ nsMsgFolderDataSource::~nsMsgFolderDataS
     NS_RELEASE(kIsSecureAtom);
     NS_RELEASE(kCanFileMessagesAtom);
     NS_RELEASE(kInVFEditSearchScopeAtom);
   }
 }
 
 nsresult nsMsgFolderDataSource::CreateLiterals(nsIRDFService *rdf)
 {
-  createNode(MOZ_UTF16("true"),
+  createNode(u"true",
     getter_AddRefs(kTrueLiteral), rdf);
-  createNode(MOZ_UTF16("false"),
+  createNode(u"false",
     getter_AddRefs(kFalseLiteral), rdf);
 
   return NS_OK;
 }
 
 nsresult nsMsgFolderDataSource::Init()
 {
   nsresult rv;
@@ -1036,17 +1036,17 @@ nsresult nsMsgFolderDataSource::createFo
 
 nsresult nsMsgFolderDataSource::CreateUnreadMessagesNameString(int32_t unreadMessages, nsAutoString &nameString)
 {
   //Only do this if unread messages are positive
   if(unreadMessages > 0)
   {
     nameString.Append(NS_LITERAL_STRING(" ("));
     nameString.AppendInt(unreadMessages);
-    nameString.Append(MOZ_UTF16(')'));
+    nameString.Append(u')');
   }
   return NS_OK;
 }
 
 nsresult
 nsMsgFolderDataSource::createFolderSpecialNode(nsIMsgFolder *folder,
                                                nsIRDFNode **target)
 {
@@ -1498,23 +1498,23 @@ nsMsgFolderDataSource::createBiffStateNo
 
 nsresult
 nsMsgFolderDataSource::createBiffStateNodeFromFlag(uint32_t flag, nsIRDFNode **target)
 {
   const char16_t *biffStateStr;
 
   switch (flag) {
     case nsIMsgFolder::nsMsgBiffState_NewMail:
-      biffStateStr = MOZ_UTF16("NewMail");
+      biffStateStr = u"NewMail";
       break;
     case nsIMsgFolder::nsMsgBiffState_NoMail:
-      biffStateStr = MOZ_UTF16("NoMail");
+      biffStateStr = u"NoMail";
       break;
     default:
-      biffStateStr = MOZ_UTF16("UnknownMail");
+      biffStateStr = u"UnknownMail";
       break;
   }
 
   createNode(biffStateStr, target, getRDFService());
   return NS_OK;
 }
 
 nsresult
@@ -1777,32 +1777,32 @@ nsMsgFolderDataSource::OnTotalMessagePro
   return NS_OK;
 }
 
 nsresult
 nsMsgFolderDataSource::GetNumMessagesNode(int32_t aNumMessages, nsIRDFNode **node)
 {
   uint32_t numMessages = aNumMessages;
   if(numMessages == kDisplayQuestionCount)
-    createNode(MOZ_UTF16("???"), node, getRDFService());
+    createNode(u"???", node, getRDFService());
   else if (numMessages == kDisplayBlankCount || numMessages == 0)
     createNode(EmptyString().get(), node, getRDFService());
   else
     createIntNode(numMessages, node, getRDFService());
   return NS_OK;
 }
 
 nsresult
 nsMsgFolderDataSource::GetFolderSizeNode(int64_t aFolderSize, nsIRDFNode **aNode)
 {
   nsresult rv;
   if (aFolderSize == kDisplayBlankCount64 || aFolderSize == 0)
     createNode(EmptyString().get(), aNode, getRDFService());
   else if (aFolderSize == kDisplayQuestionCount64)
-    createNode(MOZ_UTF16("???"), aNode, getRDFService());
+    createNode(u"???", aNode, getRDFService());
   else
   {
     nsAutoString sizeString;
     rv = FormatFileSize(aFolderSize, true, sizeString);
     NS_ENSURE_SUCCESS(rv, rv);
 
     createNode(sizeString.get(), aNode, getRDFService());
   }
@@ -1967,17 +1967,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(MOZ_UTF16("confirmSavedSearchDeleteMessage"), getter_Copies(confirmMsg));
+        sMessengerStringBundle->GetStringFromName(u"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/nsMsgGroupView.cpp
+++ b/mailnews/base/src/nsMsgGroupView.cpp
@@ -800,89 +800,89 @@ NS_IMETHODIMP nsMsgGroupView::CellTextFo
         case nsMsgViewSortType::byDate:
         {
           uint32_t ageBucket = 0;
           GetAgeBucketValue(msgHdr, &ageBucket, rcvDate);
           switch (ageBucket)
           {
           case 1:
             if (m_kTodayString.IsEmpty())
-              m_kTodayString.Adopt(GetString(MOZ_UTF16("today")));
+              m_kTodayString.Adopt(GetString(u"today"));
             aValue.Assign(m_kTodayString);
             break;
           case 2:
             if (m_kYesterdayString.IsEmpty())
-              m_kYesterdayString.Adopt(GetString(MOZ_UTF16("yesterday")));
+              m_kYesterdayString.Adopt(GetString(u"yesterday"));
             aValue.Assign(m_kYesterdayString);
             break;
           case 3:
             if (m_kLastWeekString.IsEmpty())
-              m_kLastWeekString.Adopt(GetString(MOZ_UTF16("lastWeek")));
+              m_kLastWeekString.Adopt(GetString(u"lastWeek"));
             aValue.Assign(m_kLastWeekString);
             break;
           case 4:
             if (m_kTwoWeeksAgoString.IsEmpty())
-              m_kTwoWeeksAgoString.Adopt(GetString(MOZ_UTF16("twoWeeksAgo")));
+              m_kTwoWeeksAgoString.Adopt(GetString(u"twoWeeksAgo"));
             aValue.Assign(m_kTwoWeeksAgoString);
             break;
           case 5:
             if (m_kOldMailString.IsEmpty())
-              m_kOldMailString.Adopt(GetString(MOZ_UTF16("older")));
+              m_kOldMailString.Adopt(GetString(u"older"));
             aValue.Assign(m_kOldMailString);
             break;
           default:
             // Future date, error/spoofed.
             if (m_kFutureDateString.IsEmpty())
-              m_kFutureDateString.Adopt(GetString(MOZ_UTF16("futureDate")));
+              m_kFutureDateString.Adopt(GetString(u"futureDate"));
             aValue.Assign(m_kFutureDateString);
             break;
           }
           break;
         }
         case nsMsgViewSortType::bySubject:
           FetchSubject(msgHdr, m_flags[aRow], aValue);
           break;
         case nsMsgViewSortType::byAuthor:
           FetchAuthor(msgHdr, aValue);
           break;
         case nsMsgViewSortType::byStatus:
           rv = FetchStatus(m_flags[aRow], aValue);
           if (aValue.IsEmpty()) {
-            tmp_str.Adopt(GetString(MOZ_UTF16("messagesWithNoStatus")));
+            tmp_str.Adopt(GetString(u"messagesWithNoStatus"));
             aValue.Assign(tmp_str);
           }
           break;
         case nsMsgViewSortType::byTags:
           rv = FetchTags(msgHdr, aValue);
           if (aValue.IsEmpty()) {
-            tmp_str.Adopt(GetString(MOZ_UTF16("untaggedMessages")));
+            tmp_str.Adopt(GetString(u"untaggedMessages"));
             aValue.Assign(tmp_str);
           }
           break;
         case nsMsgViewSortType::byPriority:
           FetchPriority(msgHdr, aValue);
           if (aValue.IsEmpty()) {
-            tmp_str.Adopt(GetString(MOZ_UTF16("noPriority")));
+            tmp_str.Adopt(GetString(u"noPriority"));
             aValue.Assign(tmp_str);
           }
           break;
         case nsMsgViewSortType::byAccount:
           FetchAccount(msgHdr, aValue);
           break;
         case nsMsgViewSortType::byRecipient:
           FetchRecipients(msgHdr, aValue);
           break;
         case nsMsgViewSortType::byAttachments:
           tmp_str.Adopt(GetString(flags & nsMsgMessageFlags::Attachment ?
-            MOZ_UTF16("attachments") : MOZ_UTF16("noAttachments")));
+            u"attachments" : u"noAttachments"));
           aValue.Assign(tmp_str);
           break;
         case nsMsgViewSortType::byFlagged:
           tmp_str.Adopt(GetString(flags & nsMsgMessageFlags::Marked ?
-            MOZ_UTF16("groupFlagged") : MOZ_UTF16("notFlagged")));
+            u"groupFlagged" : u"notFlagged"));
           aValue.Assign(tmp_str);
           break;
         // byLocation is a special case; we don't want to have duplicate
         //  all this logic in nsMsgSearchDBView, and its hash key is what we
         //  want anyways, so just copy it across.
         case nsMsgViewSortType::byLocation:
         case nsMsgViewSortType::byCorrespondent:
           aValue = hashKey;
--- a/mailnews/base/src/nsMsgPrintEngine.cpp
+++ b/mailnews/base/src/nsMsgPrintEngine.cpp
@@ -73,17 +73,17 @@ nsMsgPrintEngine::OnStateChange(nsIWebPr
 {
   nsresult rv = NS_OK;
 
   // top-level document load data
   if (progressStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT) {
     if (progressStateFlags & nsIWebProgressListener::STATE_START) {
       // Tell the user we are loading...
       nsString msg;
-      GetString(MOZ_UTF16("LoadingMessageToPrint"), msg);
+      GetString(u"LoadingMessageToPrint", msg);
       SetStatusMessage(msg);
     }
 
     if (progressStateFlags & nsIWebProgressListener::STATE_STOP) {
       nsCOMPtr<nsIDocumentLoader> docLoader(do_QueryInterface(aWebProgress));
       if (docLoader) 
       {
         // Check to see if the document DOMWin that is finished loading is the same
@@ -116,17 +116,17 @@ nsMsgPrintEngine::OnStateChange(nsIWebPr
         // loading the documents. If it is NULL (or not a DocLoader) then it 
         // it coming from Printing
         if (docLoader) {
           // Now, fire off the print operation!
           rv = NS_ERROR_FAILURE;
 
           // Tell the user the message is loaded...
           nsString msg;
-          GetString(MOZ_UTF16("MessageLoaded"), msg);
+          GetString(u"MessageLoaded", msg);
           SetStatusMessage(msg);
 
           NS_ASSERTION(mDocShell,"can't print, there is no docshell");
           if ( (!mDocShell) || (!aRequest) ) 
           {
             return StartNextPrintOperation();
           }
           nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(aRequest);
@@ -232,17 +232,17 @@ nsMsgPrintEngine::SetWindow(mozIDOMWindo
   nsCOMPtr<nsIDocShellTreeItem> docShellAsItem =
     do_QueryInterface(window->GetDocShell());
   NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDocShellTreeItem> rootAsItem;
   docShellAsItem->GetSameTypeRootTreeItem(getter_AddRefs(rootAsItem));
 
   nsCOMPtr<nsIDocShellTreeItem> childItem;
-  rootAsItem->FindChildWithName(MOZ_UTF16("content"), true,
+  rootAsItem->FindChildWithName(u"content", true,
 				false, nullptr, nullptr,
 				getter_AddRefs(childItem));
 
   mDocShell = do_QueryInterface(childItem);
 
   if(mDocShell)
     SetupObserver();
 
@@ -306,17 +306,17 @@ nsMsgPrintEngine::SetPrintURICount(int32
 
 NS_IMETHODIMP
 nsMsgPrintEngine::StartPrintOperation(nsIPrintSettings* aPS)
 {
   NS_ENSURE_ARG_POINTER(aPS);
   mPrintSettings = aPS;
 
   // Load the about:blank on the tail end...
-  nsresult rv = AddPrintURI(MOZ_UTF16("about:blank")); 
+  nsresult rv = AddPrintURI(u"about:blank"); 
   if (NS_FAILED(rv)) return rv; 
   return StartNextPrintOperation();
 }
 
 //----------------------------------------------------------------------
 // Set up to use the "pluggable" Print Progress Dialog
 nsresult
 nsMsgPrintEngine::ShowProgressDialog(bool aIsForPrinting, bool& aDoNotify)
@@ -372,19 +372,19 @@ nsMsgPrintEngine::ShowProgressDialog(boo
 
         if (showProgressDialog) 
         {
           nsIWebProgressListener* wpl = static_cast<nsIWebProgressListener*>(mPrintProgressListener.get());
           NS_ASSERTION(wpl, "nsIWebProgressListener is NULL!");
           NS_ADDREF(wpl);
           nsString msg;
           if (mIsDoingPrintPreview) {
-            GetString(MOZ_UTF16("LoadingMailMsgForPrintPreview"), msg);
+            GetString(u"LoadingMailMsgForPrintPreview", msg);
           } else {
-            GetString(MOZ_UTF16("LoadingMailMsgForPrint"), msg);
+            GetString(u"LoadingMailMsgForPrint", msg);
           }
           if (!msg.IsEmpty()) 
             mPrintProgressParams->SetDocTitle(msg.get());
         }
       }
     }
   }
   return rv;
@@ -406,17 +406,17 @@ nsMsgPrintEngine::StartNextPrintOperatio
   if (mCurrentlyPrintingURI >= (int32_t)mURIArray.Length())
   {
     // This is the end...dum, dum, dum....my only friend...the end
     NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
     nsPIDOMWindowOuter::From(mWindow)->Close();
 
     // Tell the user we are done...
     nsString msg;
-    GetString(MOZ_UTF16("PrintingComplete"), msg);
+    GetString(u"PrintingComplete", msg);
     SetStatusMessage(msg);
     return NS_OK;
   }
 
   if (!mDocShell)
     return StartNextPrintOperation();
 
   const nsString &uri = mURIArray[mCurrentlyPrintingURI];
@@ -594,17 +594,17 @@ nsMsgPrintEngine::PrintMsgWindow()
         mWebBrowserPrint->GetGlobalPrintSettings(getter_AddRefs(mPrintSettings));
       }
       
       // fix for bug #118887 and bug #176016
       // don't show the actual url when printing mail messages or addressbook cards.
       // for mail, it can review the salt.  for addrbook, it's a data:// url, which
       // means nothing to the end user.
       // needs to be " " and not "" or nullptr, otherwise, we'll still print the url
-      mPrintSettings->SetDocURL(MOZ_UTF16(" "));
+      mPrintSettings->SetDocURL(u" ");
 
       nsresult rv = NS_ERROR_FAILURE;
       if (mIsDoingPrintPreview) 
       {
         if (mStartupPPObs) {
           rv = mStartupPPObs->Observe(nullptr, nullptr, nullptr);
         }
       } 
--- 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(MOZ_UTF16("documentLoading"),
+      rv = mBundle->GetStringFromName(u"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(MOZ_UTF16("documentDone"),
+      rv = mBundle->GetStringFromName(u"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(
-      MOZ_UTF16("statusMessage"),
+      u"statusMessage",
       params, 2, getter_Copies(statusMessage));
     NS_ENSURE_SUCCESS(rv, rv);
   }
   else
   {
     statusMessage.Assign(str);
   }
   return ShowStatusString(statusMessage);
--- a/mailnews/base/src/nsMsgWindow.cpp
+++ b/mailnews/base/src/nsMsgWindow.cpp
@@ -81,17 +81,17 @@ NS_IMETHODIMP nsMsgWindow::GetMessageWin
   if (!docShell)
   {
     // if we don't have a docshell, then we need to look up the message pane docshell
     nsCOMPtr<nsIDocShell> rootShell(do_QueryReferent(mRootDocShellWeak));
     if (rootShell)
     {
       nsCOMPtr<nsIDocShellTreeItem> msgDocShellItem;
       if(rootShell)
-         rootShell->FindChildWithName(MOZ_UTF16("messagepane"),
+         rootShell->FindChildWithName(u"messagepane",
                                       true, false, nullptr, nullptr,
                                       getter_AddRefs(msgDocShellItem));
       NS_ENSURE_TRUE(msgDocShellItem, NS_ERROR_FAILURE);
       docShell = do_QueryInterface(msgDocShellItem);
       // we don't own mMessageWindowDocShell so don't try to keep a reference to it!
       mMessageWindowDocShellWeak = do_GetWeakReference(docShell);
     }
   }
--- a/mailnews/base/src/nsSpamSettings.cpp
+++ b/mailnews/base/src/nsSpamSettings.cpp
@@ -680,17 +680,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(
-    MOZ_UTF16("junkLogDetectStr"),
+    u"junkLogDetectStr",
     junkLogDetectFormatStrings, 3,
     getter_Copies(junkLogDetectStr));
   NS_ENSURE_SUCCESS(rv, rv);
 
   buffer += NS_ConvertUTF16toUTF8(junkLogDetectStr);
   buffer +=  "\n";
 
   if (aMoveMessage) {
@@ -702,17 +702,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(
-      MOZ_UTF16("logMoveStr"),
+      u"logMoveStr",
       logMoveFormatStrings, 2,
       getter_Copies(logMoveStr));
     NS_ENSURE_SUCCESS(rv, rv);
 
     buffer += NS_ConvertUTF16toUTF8(logMoveStr);
     buffer += "\n";
   }
 
--- a/mailnews/base/src/nsSubscribableServer.cpp
+++ b/mailnews/base/src/nsSubscribableServer.cpp
@@ -35,20 +35,20 @@ nsSubscribableServer::Init()
     rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "child"),
                                   getter_AddRefs(kNC_Child));
     NS_ENSURE_SUCCESS(rv,rv);
 
     rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Subscribed"),
                                   getter_AddRefs(kNC_Subscribed));
     NS_ENSURE_SUCCESS(rv,rv);
 
-    rv = mRDFService->GetLiteral(MOZ_UTF16("true"), getter_AddRefs(kTrueLiteral));
+    rv = mRDFService->GetLiteral(u"true", getter_AddRefs(kTrueLiteral));
     NS_ENSURE_SUCCESS(rv,rv);
 
-    rv = mRDFService->GetLiteral(MOZ_UTF16("false"), getter_AddRefs(kFalseLiteral));
+    rv = mRDFService->GetLiteral(u"false", getter_AddRefs(kFalseLiteral));
     NS_ENSURE_SUCCESS(rv,rv);
     return NS_OK;
 }
 
 nsSubscribableServer::~nsSubscribableServer(void)
 {
   mozilla::DebugOnly<nsresult> rv = FreeSubtree(mTreeRoot);
   NS_ASSERTION(NS_SUCCEEDED(rv),"failed to free tree");
--- a/mailnews/base/src/nsSubscribeDataSource.cpp
+++ b/mailnews/base/src/nsSubscribeDataSource.cpp
@@ -62,20 +62,20 @@ nsSubscribeDataSource::Init()
     rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Subscribable"),
                                   getter_AddRefs(kNC_Subscribable));
     NS_ENSURE_SUCCESS(rv,rv);
 
     rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "ServerType"),
                                   getter_AddRefs(kNC_ServerType));
     NS_ENSURE_SUCCESS(rv,rv);
 
-    rv = mRDFService->GetLiteral(MOZ_UTF16("true"), getter_AddRefs(kTrueLiteral));
+    rv = mRDFService->GetLiteral(u"true", getter_AddRefs(kTrueLiteral));
     NS_ENSURE_SUCCESS(rv,rv);
 
-    rv = mRDFService->GetLiteral(MOZ_UTF16("false"), getter_AddRefs(kFalseLiteral));
+    rv = mRDFService->GetLiteral(u"false", getter_AddRefs(kFalseLiteral));
     NS_ENSURE_SUCCESS(rv,rv);
 	return NS_OK;
 }
 
 NS_IMETHODIMP 
 nsSubscribeDataSource::GetURI(char * *aURI)
 {
   if ((*aURI = strdup("rdf:subscribe")) == nullptr)
--- a/mailnews/base/util/nsMsgDBFolder.cpp
+++ b/mailnews/base/util/nsMsgDBFolder.cpp
@@ -1922,25 +1922,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(MOZ_UTF16("autoCompactAllFoldersTitle"), getter_Copies(dialogTitle));
+          rv = bundle->GetStringFromName(u"autoCompactAllFoldersTitle", getter_Copies(dialogTitle));
           NS_ENSURE_SUCCESS(rv, rv);
-          rv = bundle->FormatStringFromName(MOZ_UTF16("autoCompactAllFoldersText"),
+          rv = bundle->FormatStringFromName(u"autoCompactAllFoldersText",
                                             params, 1, getter_Copies(confirmString));
           NS_ENSURE_SUCCESS(rv, rv);
-          rv = bundle->GetStringFromName(MOZ_UTF16("autoCompactAlwaysAskCheckbox"),
+          rv = bundle->GetStringFromName(u"autoCompactAlwaysAskCheckbox",
                                          getter_Copies(checkboxText));
           NS_ENSURE_SUCCESS(rv, rv);
-          rv = bundle->GetStringFromName(MOZ_UTF16("compactNowButton"),
+          rv = bundle->GetStringFromName(u"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);
@@ -2926,37 +2926,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(MOZ_UTF16("inboxFolderName"),
+  bundle->GetStringFromName(u"inboxFolderName",
                             &kLocalizedInboxName);
-  bundle->GetStringFromName(MOZ_UTF16("trashFolderName"),
+  bundle->GetStringFromName(u"trashFolderName",
                             &kLocalizedTrashName);
-  bundle->GetStringFromName(MOZ_UTF16("sentFolderName"),
+  bundle->GetStringFromName(u"sentFolderName",
                             &kLocalizedSentName);
-  bundle->GetStringFromName(MOZ_UTF16("draftsFolderName"),
+  bundle->GetStringFromName(u"draftsFolderName",
                             &kLocalizedDraftsName);
-  bundle->GetStringFromName(MOZ_UTF16("templatesFolderName"),
+  bundle->GetStringFromName(u"templatesFolderName",
                             &kLocalizedTemplatesName);
-  bundle->GetStringFromName(MOZ_UTF16("junkFolderName"),
+  bundle->GetStringFromName(u"junkFolderName",
                             &kLocalizedJunkName);
-  bundle->GetStringFromName(MOZ_UTF16("outboxFolderName"),
+  bundle->GetStringFromName(u"outboxFolderName",
                             &kLocalizedUnsentName);
-  bundle->GetStringFromName(MOZ_UTF16("archivesFolderName"),
+  bundle->GetStringFromName(u"archivesFolderName",
                             &kLocalizedArchivesName);
 
   nsCOMPtr<nsIStringBundle> brandBundle;
   rv = bundleService->CreateBundle("chrome://branding/locale/brand.properties", getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
-  bundle->GetStringFromName(MOZ_UTF16("brandShortName"),
+  bundle->GetStringFromName(u"brandShortName",
                             &kLocalizedBrandShortName);
   return NS_OK;
 }
 
 nsresult
 nsMsgDBFolder::createCollationKeyGenerator()
 {
   nsresult rv = NS_OK;
@@ -3846,17 +3846,17 @@ nsMsgDBFolder::ConfirmAutoFolderRename(n
   const char16_t *formatStrings[] =
   {
     aOldName.get(),
     folderName.get(),
     aNewName.get()
   };
 
   nsString confirmString;
-  rv = bundle->FormatStringFromName(MOZ_UTF16("confirmDuplicateFolderRename"),
+  rv = bundle->FormatStringFromName(u"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))) {
--- a/mailnews/base/util/nsMsgI18N.cpp
+++ b/mailnews/base/util/nsMsgI18N.cpp
@@ -253,17 +253,17 @@ bool nsMsgI18Nstateful_charset(const cha
 bool nsMsgI18Nmultibyte_charset(const char *charset)
 {
   nsresult res;
   nsCOMPtr <nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &res);
   bool result = false;
 
   if (NS_SUCCEEDED(res)) {
     nsAutoString charsetData;
-    res = ccm->GetCharsetData(charset, MOZ_UTF16(".isMultibyte"), charsetData);
+    res = ccm->GetCharsetData(charset, u".isMultibyte", charsetData);
     if (NS_SUCCEEDED(res)) {
       result = charsetData.LowerCaseEqualsLiteral("true");
     }
   }
 
   return result;
 }
 
--- a/mailnews/base/util/nsMsgIncomingServer.cpp
+++ b/mailnews/base/util/nsMsgIncomingServer.cpp
@@ -1614,18 +1614,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(MOZ_UTF16("nocachedbodybody2"), getter_Copies(errorMsgBody));
-    bundle->GetStringFromName(MOZ_UTF16("nocachedbodytitle"), getter_Copies(errorMsgTitle));
+    bundle->GetStringFromName(u"nocachedbodybody2", getter_Copies(errorMsgBody));
+    bundle->GetStringFromName(u"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
@@ -351,24 +351,24 @@ NS_IMETHODIMP nsMsgProtocol::OnStopReque
     if (!m_channelContext && NS_FAILED(aStatus) &&
         (aStatus != NS_BINDING_ABORTED))
     {
       const char16_t* errorString = nullptr;
       switch (aStatus)
       {
           case NS_ERROR_UNKNOWN_HOST:
           case NS_ERROR_UNKNOWN_PROXY_HOST:
-             errorString = MOZ_UTF16("unknownHostError");
+             errorString = u"unknownHostError";
              break;
           case NS_ERROR_CONNECTION_REFUSED:
           case NS_ERROR_PROXY_CONNECTION_REFUSED:
-             errorString = MOZ_UTF16("connectionRefusedError");
+             errorString = u"connectionRefusedError";
              break;
           case NS_ERROR_NET_TIMEOUT:
-             errorString = MOZ_UTF16("netTimeoutError");
+             errorString = u"netTimeoutError";
              break;
           default:
              // Leave the string as nullptr.
              break;
       }
 
       NS_ASSERTION(errorString, "unknown error, but don't alert user.");
       if (errorString)
--- a/mailnews/base/util/nsMsgUtils.cpp
+++ b/mailnews/base/util/nsMsgUtils.cpp
@@ -2158,35 +2158,35 @@ NS_MSG_BASE nsresult MsgPromptLoginFaile
   rv = bundleSvc->CreateBundle("chrome://messenger/locale/messenger.properties",
                                getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString message;
   NS_ConvertUTF8toUTF16 hostNameUTF16(aHostname);
   const char16_t *formatStrings[] = { hostNameUTF16.get() };
 
-  rv = bundle->FormatStringFromName(MOZ_UTF16("mailServerLoginFailed"),
+  rv = bundle->FormatStringFromName(u"mailServerLoginFailed",
                                     formatStrings, 1,
                                     getter_Copies(message));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString title;
   rv = bundle->GetStringFromName(
-    MOZ_UTF16("mailServerLoginFailedTitle"), getter_Copies(title));
+    u"mailServerLoginFailedTitle", getter_Copies(title));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString button0;
   rv = bundle->GetStringFromName(
-    MOZ_UTF16("mailServerLoginFailedRetryButton"),
+    u"mailServerLoginFailedRetryButton",
     getter_Copies(button0));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString button2;
   rv = bundle->GetStringFromName(
-    MOZ_UTF16("mailServerLoginFailedEnterNewPasswordButton"),
+    u"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
@@ -4,105 +4,105 @@
 
 #include "nsComposeStrings.h"
 
 const char16_t* errorStringNameForErrorCode(nsresult aCode)
 {
   switch(aCode)
   {
     case NS_MSG_UNABLE_TO_OPEN_FILE:
-      return MOZ_UTF16("unableToOpenFile");
+      return u"unableToOpenFile";
     case NS_MSG_UNABLE_TO_OPEN_TMP_FILE:
-      return MOZ_UTF16("unableToOpenTmpFile");
+      return u"unableToOpenTmpFile";
     case NS_MSG_UNABLE_TO_SAVE_TEMPLATE:
-      return MOZ_UTF16("unableToSaveTemplate");
+      return u"unableToSaveTemplate";
     case NS_MSG_UNABLE_TO_SAVE_DRAFT:
-      return MOZ_UTF16("unableToSaveDraft");
+      return u"unableToSaveDraft";
     case NS_MSG_COULDNT_OPEN_FCC_FOLDER:
-      return MOZ_UTF16("couldntOpenFccFolder");
+      return u"couldntOpenFccFolder";
     case NS_MSG_NO_SENDER:
-      return MOZ_UTF16("noSender");
+      return u"noSender";
     case NS_MSG_NO_RECIPIENTS:
-      return MOZ_UTF16("noRecipients");
+      return u"noRecipients";
     case NS_MSG_ERROR_WRITING_FILE:
-      return MOZ_UTF16("errorWritingFile");
+      return u"errorWritingFile";
     case NS_ERROR_SENDING_FROM_COMMAND:
-      return MOZ_UTF16("errorSendingFromCommand");
+      return u"errorSendingFromCommand";
     case NS_ERROR_SENDING_DATA_COMMAND:
-      return MOZ_UTF16("errorSendingDataCommand");
+      return u"errorSendingDataCommand";
     case NS_ERROR_SENDING_MESSAGE:
-      return MOZ_UTF16("errorSendingMessage");
+      return u"errorSendingMessage";
     case NS_ERROR_POST_FAILED:
-      return MOZ_UTF16("postFailed");
+      return u"postFailed";
     case NS_ERROR_QUEUED_DELIVERY_FAILED:
-      return MOZ_UTF16("errorQueuedDeliveryFailed");
+      return u"errorQueuedDeliveryFailed";
     case NS_ERROR_SEND_FAILED:
-      return MOZ_UTF16("sendFailed");
+      return u"sendFailed";
     case NS_ERROR_SMTP_SERVER_ERROR:
-      return MOZ_UTF16("smtpServerError");
+      return u"smtpServerError";
     case NS_MSG_UNABLE_TO_SEND_LATER:
-      return MOZ_UTF16("unableToSendLater");
+      return u"unableToSendLater";
     case NS_ERROR_COMMUNICATIONS_ERROR:
-      return MOZ_UTF16("communicationsError");
+      return u"communicationsError";
     case NS_ERROR_BUT_DONT_SHOW_ALERT:
-      return MOZ_UTF16("dontShowAlert");
+      return u"dontShowAlert";
     case NS_ERROR_TCP_READ_ERROR:
-      return MOZ_UTF16("tcpReadError");
+      return u"tcpReadError";
     case NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS:
-      return MOZ_UTF16("couldNotGetUsersMailAddress");
+      return u"couldNotGetUsersMailAddress";
     case NS_ERROR_MIME_MPART_ATTACHMENT_ERROR:
-      return MOZ_UTF16("mimeMpartAttachmentError");
+      return u"mimeMpartAttachmentError";
     case NS_MSG_FAILED_COPY_OPERATION:
-      return MOZ_UTF16("failedCopyOperation");
+      return u"failedCopyOperation";
     case NS_ERROR_NNTP_NO_CROSS_POSTING:
-      return MOZ_UTF16("nntpNoCrossPosting");
+      return u"nntpNoCrossPosting";
     case NS_MSG_CANCELLING:
-      return MOZ_UTF16("msgCancelling");
+      return u"msgCancelling";
     case NS_ERROR_SEND_FAILED_BUT_NNTP_OK:
-      return MOZ_UTF16("sendFailedButNntpOk");
+      return u"sendFailedButNntpOk";
     case NS_MSG_ERROR_READING_FILE:
-      return MOZ_UTF16("errorReadingFile");
+      return u"errorReadingFile";
     case NS_MSG_ERROR_ATTACHING_FILE:
-      return MOZ_UTF16("errorAttachingFile");
+      return u"errorAttachingFile";
     case NS_ERROR_SMTP_GREETING:
-      return MOZ_UTF16("incorrectSmtpGreeting");
+      return u"incorrectSmtpGreeting";
     case NS_ERROR_SENDING_RCPT_COMMAND:
-      return MOZ_UTF16("errorSendingRcptCommand");
+      return u"errorSendingRcptCommand";
     case NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS:
-      return MOZ_UTF16("startTlsFailed");
+      return u"startTlsFailed";
     case NS_ERROR_SMTP_PASSWORD_UNDEFINED:
-      return MOZ_UTF16("smtpPasswordUndefined");
+      return u"smtpPasswordUndefined";
     case NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED:
-      return MOZ_UTF16("smtpTempSizeExceeded");
+      return u"smtpTempSizeExceeded";
     case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1:
-      return MOZ_UTF16("smtpPermSizeExceeded1");
+      return u"smtpPermSizeExceeded1";
     case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2:
-      return MOZ_UTF16("smtpPermSizeExceeded2");
+      return u"smtpPermSizeExceeded2";
     case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER:
-      return MOZ_UTF16("smtpSendFailedUnknownServer");
+      return u"smtpSendFailedUnknownServer";
     case NS_ERROR_SMTP_SEND_FAILED_REFUSED:
-      return MOZ_UTF16("smtpSendRequestRefused");
+      return u"smtpSendRequestRefused";
     case NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED:
-      return MOZ_UTF16("smtpSendInterrupted");
+      return u"smtpSendInterrupted";
     case NS_ERROR_SMTP_SEND_FAILED_TIMEOUT:
-      return MOZ_UTF16("smtpSendTimeout");
+      return u"smtpSendTimeout";
     case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON:
-      return MOZ_UTF16("smtpSendFailedUnknownReason");
+      return u"smtpSendFailedUnknownReason";
     case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL:
-      return MOZ_UTF16("smtpHintAuthEncryptToPlainNoSsl");
+      return u"smtpHintAuthEncryptToPlainNoSsl";
     case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL:
-      return MOZ_UTF16("smtpHintAuthEncryptToPlainSsl");
+      return u"smtpHintAuthEncryptToPlainSsl";
     case NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT:
-      return MOZ_UTF16("smtpHintAuthPlainToEncrypt");
+      return u"smtpHintAuthPlainToEncrypt";
     case NS_ERROR_SMTP_AUTH_FAILURE:
-      return MOZ_UTF16("smtpAuthFailure");
+      return u"smtpAuthFailure";
     case NS_ERROR_SMTP_AUTH_GSSAPI:
-      return MOZ_UTF16("smtpAuthGssapi");
+      return u"smtpAuthGssapi";
     case NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED:
-      return MOZ_UTF16("smtpAuthMechNotSupported");
+      return u"smtpAuthMechNotSupported";
     case NS_ERROR_SMTP_AUTH_NOT_SUPPORTED:
-      return MOZ_UTF16("smtpAuthenticationNotSupported");
+      return u"smtpAuthenticationNotSupported";
     case NS_ERROR_ILLEGAL_LOCALPART:
-      return MOZ_UTF16("illegalLocalPart");
+      return u"illegalLocalPart";
     default:
-      return MOZ_UTF16("sendFailed");
+      return u"sendFailed";
   }
 }
--- a/mailnews/compose/src/nsMsgAttachmentHandler.cpp
+++ b/mailnews/compose/src/nsMsgAttachmentHandler.cpp
@@ -1164,20 +1164,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(MOZ_UTF16("failureOnObjectEmbeddingWhileSaving"),
+      bundle->FormatStringFromName(u"failureOnObjectEmbeddingWhileSaving",
                                    formatParams, 1, getter_Copies(msg));
     else
-      bundle->FormatStringFromName(MOZ_UTF16("failureOnObjectEmbeddingWhileSending"),
+      bundle->FormatStringFromName(u"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
@@ -440,17 +440,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(MOZ_UTF16("undisclosedRecipients"),
+            rv = composeStringBundle->GetStringFromName(u"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
@@ -1450,28 +1450,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, MOZ_UTF16("unableToSendLater"));
+          nsMsgDisplayMessageByName(prompt, u"unableToSendLater");
           break;
         case nsIMsgCompDeliverMode::AutoSaveAsDraft:
         case nsIMsgCompDeliverMode::SaveAsDraft:
-          nsMsgDisplayMessageByName(prompt, MOZ_UTF16("unableToSaveDraft"));
+          nsMsgDisplayMessageByName(prompt, u"unableToSaveDraft");
           break;
         case nsIMsgCompDeliverMode::SaveAsTemplate:
-          nsMsgDisplayMessageByName(prompt, MOZ_UTF16("unableToSaveTemplate"));
+          nsMsgDisplayMessageByName(prompt, u"unableToSaveTemplate");
           break;
 
         default:
-          nsMsgDisplayMessageByName(prompt, MOZ_UTF16("sendFailed"));
+          nsMsgDisplayMessageByName(prompt, u"sendFailed");
           break;
       }
     }
 
     if (progress)
       progress->CloseProgressDialog(true);
   }
 
@@ -2104,17 +2104,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(MOZ_UTF16("messageAttachmentSafeName"),
+                composeBundle->GetStringFromName(u"messageAttachmentSafeName",
                                                  getter_Copies(sanitizedSubj));
               }
               else
                 sanitizedSubj.Assign(subject);
 
               // set the file size
               uint32_t messageSize;
               msgHdr->GetMessageSize(&messageSize);
@@ -2765,17 +2765,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, MOZ_UTF16("followupToSenderMessage"));
+          nsMsgDisplayMessageByName(prompt, u"followupToSenderMessage");
 
           if (!replyTo.IsEmpty())
           {
             compFields->SetTo(replyTo);
           }
           else
           {
             // If reply-to is empty, use the From header to fetch the original
@@ -4026,17 +4026,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(MOZ_UTF16("msgCancelling"), getter_Copies(msg));
+          bundle->GetStringFromName(u"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/nsMsgComposeService.cpp
+++ b/mailnews/compose/src/nsMsgComposeService.cpp
@@ -264,17 +264,17 @@ nsMsgComposeService::GetOrigWindowSelect
     return NS_ERROR_ABORT;
 
   // Now delve down in to the message to get the HTML representation of the selection
   nsCOMPtr<nsIDocShell> rootDocShell;
   rv = aMsgWindow->GetRootDocShell(getter_AddRefs(rootDocShell));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDocShellTreeItem> childAsItem;
-  rv = rootDocShell->FindChildWithName(MOZ_UTF16("messagepane"),
+  rv = rootDocShell->FindChildWithName(u"messagepane",
                                        true, false, nullptr, nullptr, getter_AddRefs(childAsItem));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(childAsItem, &rv));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<mozIDOMWindowProxy> domWindow(do_GetInterface(childAsItem));
   NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
--- a/mailnews/compose/src/nsMsgPrompts.cpp
+++ b/mailnews/compose/src/nsMsgPrompts.cpp
@@ -49,23 +49,23 @@ 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(MOZ_UTF16("unableToOpenFile"), aFile, aResult);
+  return nsMsgBuildMessageByName(u"unableToOpenFile", aFile, aResult);
 }
 
 nsresult
 nsMsgBuildMessageWithTmpFile(nsIFile *aFile, nsString& aResult)
 {
-  return nsMsgBuildMessageByName(MOZ_UTF16("unableToOpenTmpFile"), aFile, aResult);
+  return nsMsgBuildMessageByName(u"unableToOpenTmpFile", aFile, aResult);
 }
 
 nsresult
 nsMsgDisplayMessageByName(nsIPrompt *aPrompt, const char16_t* aName, const char16_t *windowTitle)
 {
   nsString msg;
   nsMsgGetMessageByName(aName, msg);
   return nsMsgDisplayMessageByString(aPrompt, msg.get(), windowTitle);
--- a/mailnews/compose/src/nsMsgSend.cpp
+++ b/mailnews/compose/src/nsMsgSend.cpp
@@ -556,17 +556,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(MOZ_UTF16("assemblingMessage"),
+  mComposeBundle->GetStringFromName(u"assemblingMessage",
                                     getter_Copies(msg));
   SetStatusMessage( msg );
 
   /* First, open the message file.
   */
   rv = nsMsgCreateTempFile("nsemail.eml", getter_AddRefs(mTempFile));
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -923,17 +923,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(MOZ_UTF16("creatingMailMessage"),
+  mComposeBundle->GetStringFromName(u"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;
 
@@ -966,17 +966,17 @@ nsMsgComposeAndSend::GatherMimeAttachmen
     rv = mTempFile->GetFileSize(&fileSize);
     if (NS_FAILED(rv) || fileSize == 0)
     {
       status = NS_MSG_ERROR_WRITING_FILE;
       goto FAIL;
     }
   }
 
-  mComposeBundle->GetStringFromName(MOZ_UTF16("assemblingMessageDone"),
+  mComposeBundle->GetStringFromName(u"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
@@ -2516,17 +2516,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(MOZ_UTF16("gatheringAttachment"),
+      mComposeBundle->FormatStringFromName(u"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),
@@ -2544,17 +2544,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(MOZ_UTF16("errorAttachingFile"),
+          mComposeBundle->FormatStringFromName(u"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;
@@ -3036,17 +3036,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(MOZ_UTF16("assemblingMailInformation"), getter_Copies(msg));
+  mComposeBundle->GetStringFromName(u"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.
@@ -3231,17 +3231,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(MOZ_UTF16("largeMessageSendWarning"),
+    mComposeBundle->FormatStringFromName(u"largeMessageSendWarning",
                                          params, 1, getter_Copies(msg));
 
     if (!msg.IsEmpty())
     {
       nsCOMPtr<nsIPrompt> prompt;
       GetDefaultPrompt(getter_AddRefs(prompt));
       nsMsgAskBooleanQuestionByString(prompt, msg.get(), &abortTheSend);
       if (!abortTheSend)
@@ -3390,17 +3390,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(MOZ_UTF16("sendingMessage"), getter_Copies(msg));
+    mComposeBundle->GetStringFromName(u"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,
@@ -3439,17 +3439,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(MOZ_UTF16("postingMessage"),
+    mComposeBundle->GetStringFromName(u"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;
@@ -3489,17 +3489,17 @@ 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, MOZ_UTF16("sendFailed"));
+        nsMsgDisplayMessageByName(prompt, u"sendFailed");
     }
   }
 
   if (NS_SUCCEEDED(m_status))
     m_status = NS_ERROR_BUT_DONT_SHOW_ALERT;
 
   //Stop any pending process...
   Abort();
@@ -3797,19 +3797,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(MOZ_UTF16("copyMessageComplete"), getter_Copies(msg));
+    mComposeBundle->GetStringFromName(u"copyMessageComplete", getter_Copies(msg));
   else
-    mComposeBundle->GetStringFromName(MOZ_UTF16("copyMessageFailed"), getter_Copies(msg));
+    mComposeBundle->GetStringFromName(u"copyMessageFailed", getter_Copies(msg));
 
   SetStatusMessage(msg);
   nsCOMPtr<nsIPrompt> prompt;
   GetDefaultPrompt(getter_AddRefs(prompt));
 
   if (NS_FAILED(aStatus))
   {
     nsresult rv;
@@ -3818,17 +3818,17 @@ nsMsgComposeAndSend::NotifyListenerOnSto
     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;
     const char16_t *formatStrings[] = { mSavedToFolderName.get() };
 
-    rv = bundle->FormatStringFromName(MOZ_UTF16("errorSavingMsg"),
+    rv = bundle->FormatStringFromName(u"errorSavingMsg",
                                       formatStrings, 1,
                                       getter_Copies(msg));
     if (NS_SUCCEEDED(rv))
     {
       bool retry = false;
       nsMsgAskBooleanQuestionByString(prompt, msg.get(), &retry, nullptr);
       if (retry)
       {
@@ -3892,25 +3892,25 @@ nsMsgComposeAndSend::FilterSentMessage()
 }
 
 NS_IMETHODIMP
 nsMsgComposeAndSend::OnStopOperation(nsresult aStatus)
 {
   // Set a status message...
   nsString msg;
   if (NS_SUCCEEDED(aStatus))
-    mComposeBundle->GetStringFromName(MOZ_UTF16("filterMessageComplete"), getter_Copies(msg));
+    mComposeBundle->GetStringFromName(u"filterMessageComplete", getter_Copies(msg));
   else
-    mComposeBundle->GetStringFromName(MOZ_UTF16("filterMessageFailed"), getter_Copies(msg));
+    mComposeBundle->GetStringFromName(u"filterMessageFailed", getter_Copies(msg));
 
   SetStatusMessage(msg);
 
   if (NS_FAILED(aStatus))
   {
-    nsresult rv = mComposeBundle->GetStringFromName(MOZ_UTF16("errorFilteringMsg"), getter_Copies(msg));
+    nsresult rv = mComposeBundle->GetStringFromName(u"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
@@ -4329,17 +4329,17 @@ nsMsgComposeAndSend::MimeDoFCC(nsIFile  
     turi = fcc_header;
   else
     GetFolderURIFromUserPrefs(mode, mUserIdentity, turi);
   status = MessageFolderIsLocal(mUserIdentity, mode, turi.get(), &folderIsLocal);
   if (NS_FAILED(status))
     goto FAIL;
 
   // Tell the user we are copying the message...
-  mComposeBundle->GetStringFromName(MOZ_UTF16("copyMessageStart"),
+  mComposeBundle->GetStringFromName(u"copyMessageStart",
                                     getter_Copies(msg));
   if (!msg.IsEmpty())
   {
     nsCOMPtr<nsIRDFService> rdfService = do_GetService(kRDFServiceCID);
     if (rdfService)
     {
       nsCOMPtr<nsIRDFResource> res;
       rdfService->GetResource(turi, getter_AddRefs(res));
--- a/mailnews/compose/src/nsMsgSendLater.cpp
+++ b/mailnews/compose/src/nsMsgSendLater.cpp
@@ -244,17 +244,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, MOZ_UTF16("errorQueuedDeliveryFailed"));
+    nsMsgDisplayMessageByName(promptObject, u"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
@@ -297,56 +297,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(MOZ_UTF16("sendMessageErrorTitle"),
+    bundle->GetStringFromName(u"sendMessageErrorTitle",
                               getter_Copies(dialogTitle));
 
-    const char16_t* preStrName = MOZ_UTF16("sendFailed");
+    const char16_t* preStrName = u"sendFailed";
     bool askToGoBackToCompose = false;
     switch (mCurrentProcess)
     {
       case process_BuildMessage :
-        preStrName = MOZ_UTF16("sendFailed");
+        preStrName = u"sendFailed";
         askToGoBackToCompose = false;
         break;
       case process_NNTP :
-        preStrName = MOZ_UTF16("sendFailed");
+        preStrName = u"sendFailed";
         askToGoBackToCompose = false;
         break;
       case process_SMTP :
         bool nntpProceeded;
         mProcessReport[process_NNTP]->GetProceeded(&nntpProceeded);
         if (nntpProceeded)
-          preStrName = MOZ_UTF16("sendFailedButNntpOk");
+          preStrName = u"sendFailedButNntpOk";
         else
-          preStrName = MOZ_UTF16("sendFailed");
+          preStrName = u"sendFailed";
         askToGoBackToCompose = false;
         break;
       case process_Copy:
-        preStrName = MOZ_UTF16("failedCopyOperation");
+        preStrName = u"failedCopyOperation";
         askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
         break;
       case process_FCC:
-        preStrName = MOZ_UTF16("failedCopyOperation");
+        preStrName = u"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(MOZ_UTF16("genericFailureExplanation"),
+      bundle->GetStringFromName(u"genericFailureExplanation",
                                 getter_Copies(currMessage));
     }
 
     if (!currMessage.IsEmpty())
     {
       //Don't need to repeat ourself!
       if (!currMessage.Equals(dialogMessage))
       {
@@ -355,17 +355,17 @@ NS_IMETHODIMP nsMsgSendReport::DisplayRe
         dialogMessage.Append(currMessage);
       }
     }
 
     if (askToGoBackToCompose)
     {
       bool oopsGiveMeBackTheComposeWindow = true;
       nsString text1;
-      bundle->GetStringFromName(MOZ_UTF16("returnToComposeWindowQuestion"),
+      bundle->GetStringFromName(u"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;
     }
@@ -375,47 +375,47 @@ NS_IMETHODIMP nsMsgSendReport::DisplayRe
   else
   {
     const char16_t* title;
     const char16_t* messageName;
 
     switch (mDeliveryMode)
     {
       case nsIMsgCompDeliverMode::Later:
-        title = MOZ_UTF16("sendLaterErrorTitle");
-        messageName = MOZ_UTF16("unableToSendLater");
+        title = u"sendLaterErrorTitle";
+        messageName = u"unableToSendLater";
         break;
 
       case nsIMsgCompDeliverMode::AutoSaveAsDraft:
       case nsIMsgCompDeliverMode::SaveAsDraft:
-        title = MOZ_UTF16("saveDraftErrorTitle");
-        messageName = MOZ_UTF16("unableToSaveDraft");
+        title = u"saveDraftErrorTitle";
+        messageName = u"unableToSaveDraft";
         break;
 
       case nsIMsgCompDeliverMode::SaveAsTemplate:
-        title = MOZ_UTF16("saveTemplateErrorTitle");
-        messageName = MOZ_UTF16("unableToSaveTemplate");
+        title = u"saveTemplateErrorTitle";
+        messageName = u"unableToSaveTemplate";
         break;
 
       default:
         /* This should never happen! */
-        title = MOZ_UTF16("sendMessageErrorTitle");
-        messageName = MOZ_UTF16("sendFailed");
+        title = u"sendMessageErrorTitle";
+        messageName = u"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(MOZ_UTF16("genericFailureExplanation"),
+      bundle->GetStringFromName(u"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
@@ -91,17 +91,17 @@ nsresult nsExplainErrorDetails(nsISmtpUr
   NS_ENSURE_SUCCESS(rv, rv);
 
   va_start (args, aCode);
 
   const char16_t* exitString;
   switch (aCode)
   {
     case NS_ERROR_ILLEGAL_LOCALPART:
-      bundle->GetStringFromName(MOZ_UTF16("errorIllegalLocalPart"),
+      bundle->GetStringFromName(u"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:
@@ -111,17 +111,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(MOZ_UTF16("communicationsError"), getter_Copies(eMsg));
+      bundle->GetStringFromName(u"communicationsError", getter_Copies(eMsg));
       msg = nsTextFormatter::smprintf(eMsg.get(), aCode);
       break;
   }
 
   if (msg)
   {
     rv = dialog->Alert(nullptr, msg);
     nsTextFormatter::smprintf_free(msg);
@@ -1706,17 +1706,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(MOZ_UTF16("smtpDeliveringMail"));
+  UpdateStatus(u"smtpDeliveringMail");
 
   {
 //      m_runningURL->GetBodySize(&m_totalMessageSize);
   }
   return(status);
 }
 
 void nsSmtpProtocol::SendMessageInFile()
@@ -1729,17 +1729,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(MOZ_UTF16("smtpDeliveringMail"));
+  UpdateStatus(u"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...
@@ -1774,17 +1774,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(MOZ_UTF16("smtpMailSent"));
+  UpdateStatus(u"smtpMailSent");
 
   /* else */
   return SendQuit();
 }
 
 nsresult nsSmtpProtocol::SendQuit(SmtpState aNextStateAfterResponse)
 {
   m_sendDone = true;
@@ -2162,31 +2162,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(
-      MOZ_UTF16("smtpEnterPasswordPromptWithUsername"),
+      u"smtpEnterPasswordPromptWithUsername",
       formatStrings, 2, getter_Copies(passwordPromptString));
   else
     rv = composeStringBundle->FormatStringFromName(
-      MOZ_UTF16("smtpEnterPasswordPrompt"),
+      u"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(
-    MOZ_UTF16("smtpEnterPasswordPromptTitle"),
+    u"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/extensions/mailviews/src/nsMsgMailViewList.cpp
+++ b/mailnews/extensions/mailviews/src/nsMsgMailViewList.cpp
@@ -66,25 +66,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(MOZ_UTF16("mailViewPeopleIKnow"), aMailViewName);
+        rv = mBundle->GetStringFromName(u"mailViewPeopleIKnow", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewRecent))
-        rv = mBundle->GetStringFromName(MOZ_UTF16("mailViewRecentMail"), aMailViewName);
+        rv = mBundle->GetStringFromName(u"mailViewRecentMail", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewFiveDays))
-        rv = mBundle->GetStringFromName(MOZ_UTF16("mailViewLastFiveDays"), aMailViewName);
+        rv = mBundle->GetStringFromName(u"mailViewLastFiveDays", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewNotJunk))
-        rv = mBundle->GetStringFromName(MOZ_UTF16("mailViewNotJunk"), aMailViewName);
+        rv = mBundle->GetStringFromName(u"mailViewNotJunk", aMailViewName);
     else if (mName.EqualsLiteral(kDefaultViewHasAttachments))
-        rv = mBundle->GetStringFromName(MOZ_UTF16("mailViewHasAttachments"), aMailViewName);
+        rv = mBundle->GetStringFromName(u"mailViewHasAttachments", aMailViewName);
     else
         *aMailViewName = ToNewUnicode(mName);
 
     return rv;
 }
 
 NS_IMETHODIMP nsMsgMailView::GetSearchTerms(nsISupportsArray ** aSearchTerms)
 {
--- a/mailnews/extensions/mdn/src/nsMsgMdnGenerator.cpp
+++ b/mailnews/extensions/mdn/src/nsMsgMdnGenerator.cpp
@@ -466,17 +466,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(MOZ_UTF16("MsgMdnMsgSentTo"), NS_ConvertASCIItoUTF16(m_email).get(),
+    rv = FormatStringFromName(u"MsgMdnMsgSentTo", NS_ConvertASCIItoUTF16(m_email).get(),
                             getter_Copies(firstPart1));
     if (NS_FAILED(rv))
         return rv;
 
     PUSH_N_FREE_STRING (parm);
 
     PR_Free(convbuf);
 
@@ -488,42 +488,42 @@ nsresult nsMsgMdnGenerator::CreateFirstP
       PUSH_N_FREE_STRING(tmpBuffer);
     }
 
     nsString receipt_string;
     switch (m_disposeType)
     {
     case nsIMsgMdnGenerator::eDisplayed:
         rv = GetStringFromName(
-            MOZ_UTF16("MdnDisplayedReceipt"),
+            u"MdnDisplayedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eDispatched:
         rv = GetStringFromName(
-            MOZ_UTF16("MdnDispatchedReceipt"),
+            u"MdnDispatchedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eProcessed:
         rv = GetStringFromName(
-            MOZ_UTF16("MdnProcessedReceipt"),
+            u"MdnProcessedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eDeleted:
         rv = GetStringFromName(
-            MOZ_UTF16("MdnDeletedReceipt"),
+            u"MdnDeletedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eDenied:
         rv = GetStringFromName(
-            MOZ_UTF16("MdnDeniedReceipt"),
+            u"MdnDeniedReceipt",
             getter_Copies(receipt_string));
         break;
     case nsIMsgMdnGenerator::eFailed:
         rv = GetStringFromName(
-            MOZ_UTF16("MdnFailedReceipt"),
+            u"MdnFailedReceipt",
             getter_Copies(receipt_string));
         break;
     default:
         rv = NS_ERROR_INVALID_ARG;
         break;
     }
 
     if (NS_FAILED(rv))
@@ -589,42 +589,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(
-            MOZ_UTF16("MsgMdnDisplayed"),
+            u"MsgMdnDisplayed",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eDispatched:
         rv = GetStringFromName(
-            MOZ_UTF16("MsgMdnDispatched"),
+            u"MsgMdnDispatched",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eProcessed:
         rv = GetStringFromName(
-            MOZ_UTF16("MsgMdnProcessed"),
+            u"MsgMdnProcessed",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eDeleted:
         rv = GetStringFromName(
-            MOZ_UTF16("MsgMdnDeleted"),
+            u"MsgMdnDeleted",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eDenied:
         rv = GetStringFromName(
-            MOZ_UTF16("MsgMdnDenied"),
+            u"MsgMdnDenied",
             getter_Copies(firstPart2));
         break;
     case nsIMsgMdnGenerator::eFailed:
         rv = GetStringFromName(
-            MOZ_UTF16("MsgMdnFailed"),
+            u"MsgMdnFailed",
             getter_Copies(firstPart2));
         break;
     default:
         rv = NS_ERROR_INVALID_ARG;
         break;
     }
 
     if (NS_FAILED(rv))
@@ -1077,29 +1077,29 @@ NS_IMETHODIMP nsMsgMdnGenerator::OnStopR
       return NS_OK;
 
     const char16_t* exitString;
 
     switch (aExitCode)
     {
       case NS_ERROR_UNKNOWN_HOST:
       case NS_ERROR_UNKNOWN_PROXY_HOST:
-        exitString = MOZ_UTF16("smtpSendFailedUnknownServer");
+        exitString = u"smtpSendFailedUnknownServer";
         break;
       case NS_ERROR_CONNECTION_REFUSED:
       case NS_ERROR_PROXY_CONNECTION_REFUSED:
-        exitString = MOZ_UTF16("smtpSendRequestRefused");
+        exitString = u"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 = MOZ_UTF16("smtpSendInterrupted");
+        exitString = u"smtpSendInterrupted";
         break;
       case NS_ERROR_NET_TIMEOUT:
       case NS_ERROR_NET_RESET:
-        exitString = MOZ_UTF16("smtpSendTimeout");
+        exitString = u"smtpSendTimeout";
         break;
       default:
         exitString = errorStringNameForErrorCode(aExitCode);
         break;
     }
 
     nsCOMPtr<nsISmtpService> smtpService(do_GetService(NS_SMTPSERVICE_CONTRACTID, &rv));
     NS_ENSURE_SUCCESS(rv,rv);
@@ -1123,17 +1123,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(MOZ_UTF16("sendMessageErrorTitle"), getter_Copies(dialogTitle));
+    bundle->GetStringFromName(u"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/smime/src/nsMsgComposeSecure.cpp
+++ b/mailnews/extensions/smime/src/nsMsgComposeSecure.cpp
@@ -556,17 +556,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(MOZ_UTF16("mime_smimeEncryptedContentDesc"),
+  sMIMEBundle->GetStringFromName(u"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",
@@ -616,34 +616,34 @@ nsresult nsMsgComposeSecure::MimeInitEnc
 
   /* Initialize the encrypter (and add the sender's cert.) */
   PR_ASSERT(mSelfEncryptionCert);
   PR_SetError(0,0);
   mEncryptionCinfo = do_CreateInstance(NS_CMSMESSAGE_CONTRACTID, &rv);
   if (NS_FAILED(rv)) return rv;
   rv = mEncryptionCinfo->CreateEncrypted(mCerts);
   if (NS_FAILED(rv)) {
-    SetError(sendReport, MOZ_UTF16("ErrorEncryptMail"));
+    SetError(sendReport, u"ErrorEncryptMail");
     goto FAIL;
   }
 
   mEncryptionContext = do_CreateInstance(NS_CMSENCODER_CONTRACTID, &rv);
   if (NS_FAILED(rv)) return rv;
 
   if (!mBuffer) {
     mBuffer = new char[eBufferSize];
     if (!mBuffer)
       return NS_ERROR_OUT_OF_MEMORY;
   }
 
   mBufferedBytes = 0;
 
   rv = mEncryptionContext->Start(mEncryptionCinfo, mime_crypto_write_base64, mCryptoEncoder);
   if (NS_FAILED(rv)) {
-    SetError(sendReport, MOZ_UTF16("ErrorEncryptMail"));
+    SetError(sendReport, u"ErrorEncryptMail");
     goto FAIL;
   }
 
   /* If we're signing, tack a multipart/signed header onto the front of
    the data to be encrypted, and initialize the sign-hashing code too.
    */
   if (aSign) {
     rv = MimeInitMultipartSigned(false, sendReport);
@@ -672,17 +672,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(MOZ_UTF16("mime_smimeSignatureContentDesc"),
+  sMIMEBundle->GetStringFromName(u"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;
@@ -736,38 +736,38 @@ nsresult nsMsgComposeSecure::MimeFinishM
   NS_ASSERTION(mHashType, "Hash function for signature has not been set.");
 
   PR_ASSERT (mSelfSigningCert);
   PR_SetError(0,0);
 
   rv = cinfo->CreateSigned(mSelfSigningCert, mSelfEncryptionCert,
     (unsigned char*)hashString.get(), hashString.Length(), mHashType);
   if (NS_FAILED(rv))  {
-    SetError(sendReport, MOZ_UTF16("ErrorCanNotSignMail"));
+    SetError(sendReport, u"ErrorCanNotSignMail");
     goto FAIL;
   }
 
   // Initialize the base64 encoder for the signature data.
   MOZ_ASSERT(!mSigEncoder, "Shouldn't already have a mSigEncoder");
   mSigEncoder = MimeEncoder::GetBase64Encoder(
     (aOuter ? mime_encoder_output_fn : mime_nested_encoder_output_fn), this);
 
   /* Write out the signature.
    */
   PR_SetError(0,0);
   rv = encoder->Start(cinfo, mime_crypto_write_base64, mSigEncoder);
   if (NS_FAILED(rv)) {
-    SetError(sendReport, MOZ_UTF16("ErrorCanNotSignMail"));
+    SetError(sendReport, u"ErrorCanNotSignMail");
     goto FAIL;
   }
 
   // We're not passing in any data, so no update needed.
   rv = encoder->Finish();
   if (NS_FAILED(rv)) {
-    SetError(sendReport, MOZ_UTF16("ErrorCanNotSignMail"));
+    SetError(sendReport, u"ErrorCanNotSignMail");
     goto FAIL;
   }
 
   // Shut down the sig's base64 encoder.
   rv = mSigEncoder->Flush();
   mSigEncoder = nullptr;
   if (NS_FAILED(rv)) {
     goto FAIL;
@@ -831,17 +831,17 @@ nsresult nsMsgComposeSecure::MimeFinishE
     if (NS_FAILED(rv)) {
       PR_ASSERT(PR_GetError() < 0);
       goto FAIL;
     }
   }
 
   rv = mEncryptionContext->Finish();
   if (NS_FAILED(rv)) {
-    SetError(sendReport, MOZ_UTF16("ErrorEncryptMail"));
+    SetError(sendReport, u"ErrorEncryptMail");
     goto FAIL;
   }
 
   mEncryptionContext = 0;
 
   PR_ASSERT(mEncryptionCinfo);
   if (!mEncryptionCinfo) {
     rv = NS_ERROR_FAILURE;
@@ -938,22 +938,22 @@ nsresult nsMsgComposeSecure::MimeCryptoH
   }
   if (!mSelfSigningCert) {
     certdb->FindEmailSigningCert(mSigningCertName,
                                  getter_AddRefs(mSelfSigningCert));
   }
 
   // must have both the signing and encryption certs to sign
   if (!mSelfSigningCert && aSign) {
-    SetError(sendReport, MOZ_UTF16("NoSenderSigningCert"));
+    SetError(sendReport, u"NoSenderSigningCert");
     return NS_ERROR_FAILURE;
   }
 
   if (!mSelfEncryptionCert && aEncrypt) {
-    SetError(sendReport, MOZ_UTF16("NoSenderEncryptionCert"));
+    SetError(sendReport, u"NoSenderEncryptionCert");
     return NS_ERROR_FAILURE;
   }
 
 
   if (aEncrypt && mSelfEncryptionCert) {
     // Make sure self's configured cert is prepared for being used
     // as an email recipient cert.
     mozilla::ScopedCERTCertificate nsscert(mSelfEncryptionCert->GetCert());
@@ -980,17 +980,17 @@ nsresult nsMsgComposeSecure::MimeCryptoH
       ToLowerCase(mailboxes[i], mailbox_lowercase);
       nsCOMPtr<nsIX509Cert> cert;
       res = certdb->FindCertByEmailAddress(mailbox_lowercase.get(),
                                            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,
-                          MOZ_UTF16("MissingRecipientEncryptionCert"),
+                          u"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/imap/src/nsImapIncomingServer.cpp
+++ b/mailnews/imap/src/nsImapIncomingServer.cpp
@@ -1852,17 +1852,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(
-        MOZ_UTF16("imapServerAlert"),
+        u"imapServerAlert",
         params, 2, getter_Copies(message));
       if (NS_SUCCEEDED(rv))
         return AlertUser(message, aUrl);
     }
   }
   return AlertUser(aAlertString, aUrl);
 }
 
@@ -2193,17 +2193,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(
-    MOZ_UTF16("imapEnterServerPasswordPrompt"),
+    u"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;
 }
--- a/mailnews/imap/src/nsImapMailFolder.cpp
+++ b/mailnews/imap/src/nsImapMailFolder.cpp
@@ -1609,30 +1609,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(
-          MOZ_UTF16("imapSpecialChar"),
+          u"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(
-          MOZ_UTF16("imapAlertDialogTitle"),
+          u"imapAlertDialogTitle",
           titleParams, 1, getter_Copies(dialogTitle));
 
         if (dialog && !alertString.IsEmpty())
           dialog->Alert(dialogTitle.get(), alertString.get());
       }
     }
     return NS_ERROR_FAILURE;
   }
@@ -2429,30 +2429,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(
-      MOZ_UTF16("imapDeleteFolderDialogTitle"),
+      u"imapDeleteFolderDialogTitle",
       getter_Copies(deleteFolderDialogTitle));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsAutoString deleteFolderButtonLabel;
     rv = bundle->GetStringFromName(
-      MOZ_UTF16("imapDeleteFolderButtonLabel"),
+      u"imapDeleteFolderButtonLabel",
       getter_Copies(deleteFolderButtonLabel));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsAutoString confirmationStr;
     rv = bundle->FormatStringFromName((deleteNoTrash) ?
-        MOZ_UTF16("imapDeleteNoTrash") :
-        MOZ_UTF16("imapMoveFolderToTrash"),
+        u"imapDeleteNoTrash" :
+        u"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)
@@ -6063,17 +6063,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(
-      MOZ_UTF16("imapOtherUsersFolderTypeDescription"),
+      u"imapOtherUsersFolderTypeDescription",
       params, 1, getter_Copies(folderTypeDesc));
   }
   else if (GetFolderACL()->GetIsFolderShared())
   {
     folderTypeStringID = "imapPersonalSharedFolderTypeName";
     folderTypeDescStringID = "imapPersonalSharedFolderTypeDescription";
   }
   else
@@ -6594,90 +6594,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(MOZ_UTF16("imapAclFullRights"),
+    rv = bundle->GetStringFromName(u"imapAclFullRights",
                                    getter_Copies(result));
     aRightsString.Assign(result);
     return rv;
   }
   else
   {
     if (GetCanIReadFolder())
     {
-      bundle->GetStringFromName(MOZ_UTF16("imapAclReadRight"),
+      bundle->GetStringFromName(u"imapAclReadRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIWriteFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclWriteRight"),
+      bundle->GetStringFromName(u"imapAclWriteRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIInsertInFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclInsertRight"),
+      bundle->GetStringFromName(u"imapAclInsertRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanILookupFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclLookupRight"),
+      bundle->GetStringFromName(u"imapAclLookupRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIStoreSeenInFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclSeenRight"),
+      bundle->GetStringFromName(u"imapAclSeenRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIDeleteInFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclDeleteRight"),
+      bundle->GetStringFromName(u"imapAclDeleteRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIExpungeFolder())
     {
       if (!aRightsString.IsEmpty())
         aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclExpungeRight"),
+      bundle->GetStringFromName(u"imapAclExpungeRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanICreateSubfolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclCreateRight"),
+      bundle->GetStringFromName(u"imapAclCreateRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIPostToFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclPostRight"),
+      bundle->GetStringFromName(u"imapAclPostRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
     if (GetCanIAdministerFolder())
     {
       if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
-      bundle->GetStringFromName(MOZ_UTF16("imapAclAdministerRight"),
+      bundle->GetStringFromName(u"imapAclAdministerRight",
                                 getter_Copies(curRight));
       aRightsString.Append(curRight);
     }
   }
   return rv;
 }
 
 NS_IMETHODIMP nsImapMailFolder::GetFilePath(nsIFile ** aPathName)
@@ -8212,17 +8212,17 @@ nsImapMailFolder::CopyStreamMessage(nsIM
                                             totalMsgString.get(),
                                             dstFolderName.get()
                                             };
 
       nsCOMPtr <nsIStringBundle> bundle;
       rv = IMAPGetStringBundle(getter_AddRefs(bundle));
       NS_ENSURE_SUCCESS(rv, rv);
       rv = bundle->FormatStringFromName(
-        MOZ_UTF16("imapCopyingMessageOf2"),
+        u"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
@@ -546,17 +546,17 @@ nsImapProtocol::Initialize(nsIImapHostSe
   m_parser.SetHostSessionList(aHostSessionList);
   m_parser.SetFlagState(m_flagState);
 
   // Initialize the empty mime part string on the main thread.
   nsCOMPtr<nsIStringBundle> bundle;
   rv = IMAPGetStringBundle(getter_AddRefs(bundle));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = bundle->GetStringFromName(MOZ_UTF16("imapEmptyMimePart"),
+  rv = bundle->GetStringFromName(u"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))
--- a/mailnews/imap/src/nsImapService.cpp
+++ b/mailnews/imap/src/nsImapService.cpp
@@ -2748,17 +2748,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(
-        MOZ_UTF16("imapSubscribePrompt"),
+        u"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/import/applemail/src/nsAppleMailImport.cpp
+++ b/mailnews/import/applemail/src/nsAppleMailImport.cpp
@@ -58,23 +58,23 @@ nsAppleMailImportModule::~nsAppleMailImp
 
 
 NS_IMPL_ISUPPORTS(nsAppleMailImportModule, nsIImportModule)
 
 
 NS_IMETHODIMP nsAppleMailImportModule::GetName(char16_t **aName)
 {
   return mBundle ?
-    mBundle->GetStringFromName(MOZ_UTF16("ApplemailImportName"), aName) : NS_ERROR_FAILURE;
+    mBundle->GetStringFromName(u"ApplemailImportName", aName) : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP nsAppleMailImportModule::GetDescription(char16_t **aName)
 {
   return mBundle ?
-    mBundle->GetStringFromName(MOZ_UTF16("ApplemailImportDescription"), aName) : NS_ERROR_FAILURE;
+    mBundle->GetStringFromName(u"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;
 }
@@ -97,17 +97,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(MOZ_UTF16("ApplemailImportName"), getter_Copies(name));
+          rv = mBundle->GetStringFromName(u"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);
@@ -470,17 +470,17 @@ nsAppleMailImportMail::ImportMailbox(nsI
   mProgress = 0;
 
   nsAutoString mailboxName;
   aMailbox->GetDisplayName(getter_Copies(mailboxName));
 
   nsCOMPtr<nsIFile> mboxFolder;
   nsresult rv = aMailbox->GetFile(getter_AddRefs(mboxFolder));
   if (NS_FAILED(rv) || !mboxFolder) {
-    ReportStatus(MOZ_UTF16("ApplemailImportMailboxConverterror"), mailboxName, errorLog);
+    ReportStatus(u"ApplemailImportMailboxConverterror", mailboxName, errorLog);
     SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
     return NS_ERROR_FAILURE;
   }
 
   // if we're an account mailbox, nothing do. if we're a real mbox
   // then we've got some messages to import!
   uint32_t mailboxIdentifier;
   aMailbox->GetIdentifier(&mailboxIdentifier);
@@ -496,35 +496,35 @@ nsAppleMailImportMail::ImportMailbox(nsI
       //
       // just indicate that we're done, using the same number that we used to estimate
       // number of messages earlier.
       uint32_t finalSize;
       aMailbox->GetSize(&finalSize);
       mProgress = finalSize;
 
       // report that we successfully imported this mailbox
-      ReportStatus(MOZ_UTF16("ApplemailImportMailboxSuccess"), mailboxName, successLog);
+      ReportStatus(u"ApplemailImportMailboxSuccess", mailboxName, successLog);
       SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
       return NS_OK;
     }
 
     // let's import the messages!
     nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
     rv = messagesFolder->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
     if (NS_FAILED(rv)) {
-      ReportStatus(MOZ_UTF16("ApplemailImportMailboxConvertError"), mailboxName, errorLog);
+      ReportStatus(u"ApplemailImportMailboxConvertError", mailboxName, errorLog);
       SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
       return NS_ERROR_FAILURE;
     }
 
     // prepare an outstream to the destination file
     nsCOMPtr<nsIMsgPluggableStore> msgStore;
     rv = aDstFolder->GetMsgStore(getter_AddRefs(msgStore));
     if (!msgStore || NS_FAILED(rv)) {
-      ReportStatus(MOZ_UTF16("ApplemailImportMailboxConverterror"), mailboxName, errorLog);
+      ReportStatus(u"ApplemailImportMailboxConverterror", mailboxName, errorLog);
       SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
       return NS_ERROR_FAILURE;
     }
 
     bool hasMore = false;
     nsCOMPtr<nsIOutputStream> outStream;
 
     while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) && hasMore) {
@@ -576,17 +576,17 @@ nsAppleMailImportMail::ImportMailbox(nsI
   }
   // just indicate that we're done, using the same number that we used to estimate
   // number of messages earlier.
   uint32_t finalSize;
   aMailbox->GetSize(&finalSize);
   mProgress = finalSize;
 
   // report that we successfully imported this mailbox
-  ReportStatus(MOZ_UTF16("ApplemailImportMailboxSuccess"), mailboxName, successLog);
+  ReportStatus(u"ApplemailImportMailboxSuccess", mailboxName, successLog);
   SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
 
   return NS_OK;
 }
 
 void nsAppleMailImportMail::ReportStatus(const char16_t* aErrorName, nsString &aName,
                                          nsAString &aStream)
 {
--- a/mailnews/import/becky/src/nsBeckyAddressBooks.cpp
+++ b/mailnews/import/becky/src/nsBeckyAddressBooks.cpp
@@ -56,17 +56,17 @@ nsBeckyAddressBooks::GetSupportsMultiple
 NS_IMETHODIMP
 nsBeckyAddressBooks::GetAutoFind(char16_t **aDescription,
                                  bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(aDescription);
   NS_ENSURE_ARG_POINTER(_retval);
 
   *aDescription =
-    nsBeckyStringBundle::GetStringByName(MOZ_UTF16("BeckyImportDescription"));
+    nsBeckyStringBundle::GetStringByName(u"BeckyImportDescription");
   *_retval = false;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBeckyAddressBooks::GetNeedsFieldMap(nsIFile *aLocation, bool *_retval)
 {
@@ -349,17 +349,17 @@ nsBeckyAddressBooks::ImportAddressBook(n
     if (NS_FAILED(rv)) {
       break;
     }
   }
 
   if (!error.IsEmpty())
     *aErrorLog = ToNewUnicode(error);
   else
-    *aSuccessLog = nsBeckyStringBundle::GetStringByName(MOZ_UTF16("BeckyImportAddressSuccess"));
+    *aSuccessLog = nsBeckyStringBundle::GetStringByName(u"BeckyImportAddressSuccess");
 
   return rv;
 }
 
 NS_IMETHODIMP
 nsBeckyAddressBooks::GetImportProgress(uint32_t *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
--- a/mailnews/import/becky/src/nsBeckyFilters.cpp
+++ b/mailnews/import/becky/src/nsBeckyFilters.cpp
@@ -95,17 +95,17 @@ nsBeckyFilters::AutoLocate(char16_t **aD
                            nsIFile **aLocation,
                            bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(aLocation);
   NS_ENSURE_ARG_POINTER(_retval);
 
   if (aDescription) {
     *aDescription =
-      nsBeckyStringBundle::GetStringByName(MOZ_UTF16("BeckyImportDescription"));
+      nsBeckyStringBundle::GetStringByName(u"BeckyImportDescription");
   }
   *aLocation = nullptr;
   *_retval = false;
 
   nsresult rv;
   nsCOMPtr<nsIFile> location;
   rv = GetDefaultFilterLocation(getter_AddRefs(location));
   if (NS_FAILED(rv))
--- a/mailnews/import/becky/src/nsBeckyImport.cpp
+++ b/mailnews/import/becky/src/nsBeckyImport.cpp
@@ -47,26 +47,26 @@ nsBeckyImport::~nsBeckyImport()
 
 NS_IMPL_ISUPPORTS(nsBeckyImport, nsIImportModule)
 
 NS_IMETHODIMP
 nsBeckyImport::GetName(char16_t **aName)
 {
   NS_ENSURE_ARG_POINTER(aName);
   *aName =
-    nsBeckyStringBundle::GetStringByName(MOZ_UTF16("BeckyImportName"));
+    nsBeckyStringBundle::GetStringByName(u"BeckyImportName");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBeckyImport::GetDescription(char16_t **aDescription)
 {
   NS_ENSURE_ARG_POINTER(aDescription);
   *aDescription =
-    nsBeckyStringBundle::GetStringByName(MOZ_UTF16("BeckyImportDescription"));
+    nsBeckyStringBundle::GetStringByName(u"BeckyImportDescription");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBeckyImport::GetSupports(char **aSupports)
 {
   NS_ENSURE_ARG_POINTER(aSupports);
   *aSupports = strdup(kBeckySupportsString);
@@ -92,17 +92,17 @@ nsBeckyImport::GetMailImportInterface(ns
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIImportGeneric> generic;
   rv = importService->CreateNewGenericMail(getter_AddRefs(generic));
   NS_ENSURE_SUCCESS(rv, rv);
 
   generic->SetData("mailInterface", importer);
 
   nsString name;
-  name.Adopt(nsBeckyStringBundle::GetStringByName(MOZ_UTF16("BeckyImportName")));
+  name.Adopt(nsBeckyStringBundle::GetStringByName(u"BeckyImportName"));
 
   nsCOMPtr<nsISupportsString> nameString(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nameString->SetData(name);
   generic->SetData("name", nameString);
 
   return CallQueryInterface(generic, aInterface);
--- a/mailnews/import/becky/src/nsBeckyMail.cpp
+++ b/mailnews/import/becky/src/nsBeckyMail.cpp
@@ -609,17 +609,17 @@ nsBeckyMail::ImportMailbox(nsIImportMail
   mReadBytes = finalSize;
 
   nsAutoString name;
   aSource->GetDisplayName(getter_Copies(name));
 
   nsAutoString successMessage;
   const char16_t *format = { name.get() };
   rv =
-      nsBeckyStringBundle::FormatStringFromName(MOZ_UTF16("BeckyImportMailboxSuccess"),
+      nsBeckyStringBundle::FormatStringFromName(u"BeckyImportMailboxSuccess",
                                                 &format,
                                                 1,
                                                 getter_Copies(successMessage));
   successMessage.AppendLiteral("\n");
   *aSuccessLog = ToNewUnicode(successMessage);
 
   return rv;
 }
--- a/mailnews/import/becky/src/nsBeckySettings.cpp
+++ b/mailnews/import/becky/src/nsBeckySettings.cpp
@@ -50,17 +50,17 @@ nsBeckySettings::AutoLocate(char16_t **a
                             nsIFile **aLocation,
                             bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(aDescription);
   NS_ENSURE_ARG_POINTER(aLocation);
   NS_ENSURE_ARG_POINTER(_retval);
 
   *aDescription =
-    nsBeckyStringBundle::GetStringByName(MOZ_UTF16("BeckyImportName"));
+    nsBeckyStringBundle::GetStringByName(u"BeckyImportName");
   *aLocation = nullptr;
   *_retval = false;
 
   nsCOMPtr<nsIFile> location;
   nsresult rv = nsBeckyUtils::GetDefaultMailboxINIFile(getter_AddRefs(location));
   if (NS_FAILED(rv))
     location = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   else
--- a/mailnews/import/outlook/src/nsOutlookCompose.cpp
+++ b/mailnews/import/outlook/src/nsOutlookCompose.cpp
@@ -174,23 +174,23 @@ nsresult OutlookSendListener::CreateSend
 }
 
 /////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////
 
 #define hackBeginA "begin"
-#define hackBeginW MOZ_UTF16(hackBeginA)
+#define hackBeginW u"begin"
 #define hackEndA "\015\012end"
-#define hackEndW MOZ_UTF16(hackEndA)
+#define hackEndW u"\015\012end"
 #define hackCRLFA "crlf"
-#define hackCRLFW MOZ_UTF16(hackCRLFA)
+#define hackCRLFW u"crlf"
 #define hackAmpersandA "amp"
-#define hackAmpersandW MOZ_UTF16(hackAmpersandA)
+#define hackAmpersandW u"amp"
 
 nsOutlookCompose::nsOutlookCompose()
 {
   m_pListener = nullptr;
   m_pMsgFields = nullptr;
 
   m_optimizationBufferSize = 16*1024;
   m_optimizationBuffer = new char[m_optimizationBufferSize];
--- a/mailnews/import/src/nsImportMail.cpp
+++ b/mailnews/import/src/nsImportMail.cpp
@@ -902,22 +902,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(MOZ_UTF16("ImportModuleFolderName"),
+    rv = bundle->FormatStringFromName(u"ImportModuleFolderName",
                                       moduleName, 1,
                                       getter_Copies(folderName));
   }
   else {
-    rv = bundle->GetStringFromName(MOZ_UTF16("DefaultFolderName"),
+    rv = bundle->GetStringFromName(u"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/intl/nsCharsetConverterManager.cpp
+++ b/mailnews/intl/nsCharsetConverterManager.cpp
@@ -106,17 +106,17 @@ nsresult GetCharsetDataImpl(const char *
 }
 
 //static
 bool nsCharsetConverterManager::IsInternal(const nsACString& aCharset)
 {
   nsAutoString str;
   // fully qualify to possibly avoid vtable call
   nsresult rv = GetCharsetDataImpl(PromiseFlatCString(aCharset).get(),
-                                   MOZ_UTF16(".isInternal"),
+                                   u".isInternal",
                                    str);
 
   return NS_SUCCEEDED(rv);
 }
 
 
 //----------------------------------------------------------------------------//----------------------------------------------------------------------------
 // Interface nsICharsetConverterManager [implementation]
@@ -340,17 +340,17 @@ NS_IMETHODIMP
 nsCharsetConverterManager::GetCharsetLangGroupRaw(const char * aCharset, 
                                                   nsIAtom** aResult)
 {
 
   *aResult = nullptr;
   nsAutoString langGroup;
   // fully qualify to possibly avoid vtable call
   nsresult rv = nsCharsetConverterManager::GetCharsetData(
-      aCharset, MOZ_UTF16(".LangGroup"), langGroup);
+      aCharset, u".LangGroup", langGroup);
 
   if (NS_SUCCEEDED(rv)) {
     ToLowerCase(langGroup); // use lowercase for all language atoms
     *aResult = NS_Atomize(langGroup).take();
   }
 
   return rv;
 }
--- a/mailnews/local/src/nsLocalMailFolder.cpp
+++ b/mailnews/local/src/nsLocalMailFolder.cpp
@@ -839,29 +839,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(
-        MOZ_UTF16("pop3DeleteFolderDialogTitle"),
+        u"pop3DeleteFolderDialogTitle",
         getter_Copies(deleteFolderDialogTitle));
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsAutoString deleteFolderButtonLabel;
       rv = bundle->GetStringFromName(
-        MOZ_UTF16("pop3DeleteFolderButtonLabel"),
+        u"pop3DeleteFolderButtonLabel",
         getter_Copies(deleteFolderButtonLabel));
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsAutoString confirmationStr;
       rv = bundle->FormatStringFromName(
-        MOZ_UTF16("pop3MoveFolderToTrash"), formatStrings, 1,
+        u"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".
@@ -3311,18 +3311,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) ?
-        MOZ_UTF16("movingMessagesStatus") :
-        MOZ_UTF16("copyingMessagesStatus"),
+        u"movingMessagesStatus" :
+        u"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/nsPop3Protocol.cpp
+++ b/mailnews/local/src/nsPop3Protocol.cpp
@@ -855,29 +855,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(
-      MOZ_UTF16("pop3PreviouslyEnteredPasswordIsInvalidPrompt"),
+      u"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(
-      MOZ_UTF16("pop3EnterPasswordPrompt"),
+      u"pop3EnterPasswordPrompt",
       passwordParams, 2, getter_Copies(passwordPrompt));
 
   nsString passwordTitle;
   mLocalBundle->GetStringFromName(
-    MOZ_UTF16("pop3EnterPasswordPromptTitle"),
+    u"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);
 
@@ -1263,17 +1263,17 @@ 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(
-      MOZ_UTF16("pop3ErrorDialogTitle"),
+      u"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
@@ -1301,17 +1301,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(
-                    MOZ_UTF16("pop3ServerSaid"),
+                    u"pop3ServerSaid",
                     params, 1, getter_Copies(serverSaidPrefix));
                 }
 
                 nsAutoString message(alertString);
                 message.AppendLiteral(" ");
                 message.Append(serverSaidPrefix);
                 message.AppendLiteral(" ");
                 message.Append(NS_ConvertASCIItoUTF16(m_commandResponse));
@@ -3448,17 +3448,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(
-      MOZ_UTF16("pop3ServerDoesNotSupportTopCommand"),
+      u"pop3ServerDoesNotSupportTopCommand",
       getter_Copies(statusTemplate));
     if (!statusTemplate.IsEmpty())
     {
       nsAutoCString hostName;
       char16_t * statusString = nullptr;
       m_url->GetHost(hostName);
 
       statusString = nsTextFormatter::smprintf(statusTemplate.get(), hostName.get());
@@ -3826,17 +3826,17 @@ nsresult nsPop3Protocol::ProcessProtocol
       status = AuthNtlmResponse();
       break;
 
     case POP3_AUTH_GSSAPI:
       status = AuthGSSAPI();
       break;
 
     case POP3_AUTH_GSSAPI_FIRST:
-      UpdateStatus(MOZ_UTF16("hostContact"));
+      UpdateStatus(u"hostContact");
       status = AuthGSSAPIResponse(true);
       break;
 
     case POP3_AUTH_GSSAPI_STEP:
       status = AuthGSSAPIResponse(false);
       break;
 
     case POP3_SEND_USERNAME:
@@ -3844,17 +3844,17 @@ nsresult nsPop3Protocol::ProcessProtocol
         status = -1;
       break;
 
     case POP3_OBTAIN_PASSWORD_BEFORE_USERNAME:
       status = -1;
       break;
 
     case POP3_FINISH_OBTAIN_PASSWORD_BEFORE_USERNAME:
-      UpdateStatus(MOZ_UTF16("hostContact"));
+      UpdateStatus(u"hostContact");
       status = SendUsername();
       break;
 
     case POP3_SEND_PASSWORD:
       if (NS_FAILED(StartGetAsyncPassword(POP3_OBTAIN_PASSWORD_BEFORE_PASSWORD)))
         status = -1;
       break;
 
@@ -3952,17 +3952,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(MOZ_UTF16("noNewMessages"));
+            UpdateStatus(u"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/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(
-    MOZ_UTF16("pop3ServerBusy"),
+    u"pop3ServerBusy",
     params, 1, getter_Copies(alertString));
   bundle->FormatStringFromName(
-    MOZ_UTF16("pop3ErrorDialogTitle"),
+    u"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
@@ -685,17 +685,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(
-    MOZ_UTF16("pop3TmpDownloadError"),
+    u"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
@@ -141,32 +141,32 @@ 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(
-                       MOZ_UTF16("brandFullName"),
+                       u"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,
                                       getter_Copies(loginTitle));
     if (NS_FAILED(rv)) return false;
 
     if (aLogin)
     {
       nsString loginText;
-      rv = bundle->GetStringFromName(MOZ_UTF16("loginTextwithName"),
+      rv = bundle->GetStringFromName(u"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);
     }
@@ -250,22 +250,22 @@ 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(MOZ_UTF16("mapiBlindSendWarning"),
+  rv = bundle->GetStringFromName(u"mapiBlindSendWarning",
                                       getter_Copies(warningMsg));
   if (NS_FAILED(rv)) return false;
 
   nsString dontShowAgainMessage;
-  rv = bundle->GetStringFromName(MOZ_UTF16("mapiBlindSendDontShowAgain"),
+  rv = bundle->GetStringFromName(u"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;
--- 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  "pgpMimeNeedsAddon"
+#define PGPMIME_STR_NOT_SUPPORTED_ID  u"pgpMimeNeedsAddon"
 #define PGPMIME_URL_PREF              "mail.pgpmime.addon_url"
 
 static void PgpMimeGetNeedsAddonString(nsCString &aResult)
 {
   aResult.AssignLiteral("???");
 
   nsCOMPtr<nsIStringBundleService> stringBundleService =
     mozilla::services::GetStringBundleService();
@@ -82,17 +82,17 @@ static void PgpMimeGetNeedsAddonString(n
   if (NS_FAILED(prefs->GetCharPref("mail.pgpmime.addon_url",
                                    getter_Copies(url))))
     return;
 
   NS_ConvertUTF8toUTF16 url16(url);
   const char16_t *formatStrings[] = { url16.get() };
 
   nsString result;
-  rv = stringBundle->FormatStringFromName(MOZ_UTF16(PGPMIME_STR_NOT_SUPPORTED_ID),
+  rv = stringBundle->FormatStringFromName(PGPMIME_STR_NOT_SUPPORTED_ID,
                                           formatStrings, 1, getter_Copies(result));
   if (NS_FAILED(rv))
     return;
   aResult = NS_ConvertUTF16toUTF8(result);
 }
 
 static int
 MimeEncryptedPgpClassInitialize(MimeEncryptedPgpClass *clazz)
--- a/mailnews/mime/emitters/nsMimeBaseEmitter.cpp
+++ b/mailnews/mime/emitters/nsMimeBaseEmitter.cpp
@@ -735,17 +735,17 @@ nsMimeBaseEmitter::GenerateDateString(co
     {
       if (displaySenderTimezone)
       {
         // offset of local time from UTC in minutes
         int32_t senderoffset = (explodedMsgTime.tm_params.tp_gmt_offset +
                                 explodedMsgTime.tm_params.tp_dst_offset) / 60;
         // append offset to date string
         char16_t *tzstring =
-          nsTextFormatter::smprintf(MOZ_UTF16(" %+05d"),
+          nsTextFormatter::smprintf(u" %+05d",
                                     (senderoffset / 60 * 100) +
                                     (senderoffset % 60));
         formattedDateString.Append(tzstring);
         nsTextFormatter::smprintf_free(tzstring);
       }
 
       CopyUTF16toUTF8(formattedDateString, formattedDate);
     }
--- a/mailnews/mime/emitters/nsMimeHtmlEmitter.cpp
+++ b/mailnews/mime/emitters/nsMimeHtmlEmitter.cpp
@@ -414,17 +414,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(MOZ_UTF16("attachmentsPrintHeader"),
+      bundle->GetStringFromName(u"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/mimemsg.cpp
+++ b/mailnews/mime/src/mimemsg.cpp
@@ -861,26 +861,26 @@ MimeMessage_partial_message_html(const c
   nsCString partialMsgHtml;
   nsCString item;
 
   partialMsgHtml.AppendLiteral("<div style=\"margin: 1em auto; border: 1px solid black; width: 80%\">");
   partialMsgHtml.AppendLiteral("<div style=\"margin: 5px; padding: 10px; border: 1px solid gray; font-weight: bold; text-align: center;\">");
 
   partialMsgHtml.AppendLiteral("<span style=\"font-size: 120%;\">");
   if (msgBaseTruncated)
-    item.Adopt(MimeGetStringByName(MOZ_UTF16("MIME_MSG_PARTIAL_TRUNCATED")));
+    item.Adopt(MimeGetStringByName(u"MIME_MSG_PARTIAL_TRUNCATED"));
   else
-    item.Adopt(MimeGetStringByName(MOZ_UTF16("MIME_MSG_PARTIAL_NOT_DOWNLOADED")));
+    item.Adopt(MimeGetStringByName(u"MIME_MSG_PARTIAL_NOT_DOWNLOADED"));
   partialMsgHtml += item;
   partialMsgHtml.AppendLiteral("</span><hr>");
 
   if (msgBaseTruncated)
-    item.Adopt(MimeGetStringByName(MOZ_UTF16("MIME_MSG_PARTIAL_TRUNCATED_EXPLANATION")));
+    item.Adopt(MimeGetStringByName(u"MIME_MSG_PARTIAL_TRUNCATED_EXPLANATION"));
   else
-    item.Adopt(MimeGetStringByName(MOZ_UTF16("MIME_MSG_PARTIAL_NOT_DOWNLOADED_EXPLANATION")));
+    item.Adopt(MimeGetStringByName(u"MIME_MSG_PARTIAL_NOT_DOWNLOADED_EXPLANATION"));
   partialMsgHtml += item;
   partialMsgHtml.AppendLiteral("<br><br>");
 
   partialMsgHtml.AppendLiteral("<a href=\"");
   partialMsgHtml.Append(orig_url);
 
   if (msgIdPtr) {
     partialMsgHtml.AppendLiteral("&messageid=");
@@ -896,17 +896,17 @@ MimeMessage_partial_message_html(const c
 
     MsgEscapeString(nsDependentCString(uidl), nsINetUtil::ESCAPE_XALPHAS,
                     item);
 
     partialMsgHtml.Append(item);
   }
 
   partialMsgHtml.AppendLiteral("\">");
-  item.Adopt(MimeGetStringByName(MOZ_UTF16("MIME_MSG_PARTIAL_CLICK_FOR_REST")));
+  item.Adopt(MimeGetStringByName(u"MIME_MSG_PARTIAL_CLICK_FOR_REST"));
   partialMsgHtml += item;
   partialMsgHtml.AppendLiteral("</a>");
 
   partialMsgHtml.AppendLiteral("</div></div>");
 
   return ToNewCString(partialMsgHtml);
 }
 
--- a/mailnews/news/src/nsNNTPNewsgroupList.cpp
+++ b/mailnews/news/src/nsNNTPNewsgroupList.cpp
@@ -311,17 +311,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(MOZ_UTF16("noNewMessages"), getter_Copies(statusString));
+    rv = bundle->GetStringFromName(u"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(MOZ_UTF16("downloadingArticles"), formatStrings, 2, getter_Copies(statusString));
+      rv = bundle->FormatStringFromName(u"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(MOZ_UTF16("statusMessage"),
+      bundle->FormatStringFromName(u"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(MOZ_UTF16("newNewsgroupFilteringHeaders"),
+    rv = bundle->FormatStringFromName(u"newNewsgroupFilteringHeaders",
       formatStrings, 4, getter_Copies(statusString));
   }
   else
   {
     const char16_t *formatStrings[3] = { numDownloadedStr.get(),
       totalToDownloadStr.get(), newsgroupName.get() };
-    rv = bundle->FormatStringFromName(MOZ_UTF16("newNewsgroupHeaders"),
+    rv = bundle->FormatStringFromName(u"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
@@ -1036,17 +1036,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(
-        MOZ_UTF16("autoSubscribeText"), formatStrings, 1,
+        u"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)
@@ -2773,17 +2773,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(MOZ_UTF16("bytesReceived"),
+      rv = bundle->FormatStringFromName(u"bytesReceived",
         formatStrings, 3,
         getter_Copies(statusString));
 
       rv = msgStatusFeedback->ShowStatusString(statusString);
       if (NS_FAILED(rv)) {
         PR_Free(lineToFree);
         return rv;
       }
@@ -3540,17 +3540,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(MOZ_UTF16("brandFullName"),
+  rv = brandBundle->GetStringFromName(u"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 prettiestName;
     nsString statusString;
 
     m_folder->GetPrettiestName(prettiestName);
 
     const char16_t *formatStrings[3] = { firstStr.get(), totalStr.get(), prettiestName.get() };
-    rv = bundle->FormatStringFromName(MOZ_UTF16("downloadingArticlesForOffline"),
+    rv = bundle->FormatStringFromName(u"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
@@ -1233,17 +1233,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(MOZ_UTF16("enterUserPassTitle"),
+      bundle->GetStringFromName(u"enterUserPassTitle",
         getter_Copies(promptTitle));
 
       nsString serverName;
       nsCOMPtr<nsIMsgIncomingServer> server;
       rv = GetServer(getter_AddRefs(server));
       NS_ENSURE_SUCCESS(rv, rv);
 
       server->GetPrettyName(serverName);
@@ -1255,21 +1255,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(
-          MOZ_UTF16("enterUserPassServer"),
+          u"enterUserPassServer",
           &params[1], 1, getter_Copies(promptText));
       else
         bundle->FormatStringFromName(
-          MOZ_UTF16("enterUserPassGroup"),
+          u"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
@@ -1579,17 +1579,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(
-                    MOZ_UTF16("autoUnsubscribeText"),
+                    u"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
@@ -81,17 +81,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(MOZ_UTF16("brandShortName"),
+  rv = brandBundle->GetStringFromName(u"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
@@ -770,17 +770,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
-                      (MOZ_UTF16("desktopBackgroundLeafNameWin"),
+                      (u"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);